Usar un sensor de temperatura con tu placa Arduino es muy fácil, y es la forma más rápida de empezar a conocer el fascinante mundo de los sensores.
La temperatura es una de las magnitudes físicas que más necesitan medirse, por ello, se han desarrollado varios tipos de sensores para diferentes aplicaciones, tanto a nivel doméstico como en procesos industriales.
¿Qué es un sensor de temperatura?
Un sensor de temperatura es un dispositivo que transforma los cambios de temperatura (magnitud fisíca) en señales eléctricas (voltaje), que luego pueden ser procesadas por equipos eléctricos o electrónicos.
El sensor de temperatura, típicamente suele estar formado por el elemento sensor, y la cubierta o capsula protectora que lo envuelve.
Entre ambos existe un material de relleno, altamente conductor de la temperatura, para que los cambios se transmitan rápidamente al elemento sensor.
Aplicaciones de un sensor de temperatura
Los sensores de temperatura se usan para medir la temperatura del aire o la temperatura superficial de líquidos y sólidos.
Se usan comúnmente en proyectos de estaciones meteorológicas o en un termostato doméstico. Hay varias formas de medir la temperatura.
En la industria, su aplicación más amplia es en áreas como la elaboración de alimentos, climatización para control ambiental, dispositivos médicos, manipulación de productos químicos y control de dispositivos en el sector automotriz.
Hay dos variedades principales de sensores de temperatura: con contacto y sin contacto.
Los sensores de temperatura de contacto incluyen los termopares y termistores que hacen contacto con el objeto a medir.
Los sensores de temperatura sin contacto se encargan de medir la radiación térmica emitida por una fuente de calor para determinar su temperatura. Este último grupo mide la temperatura a distancia y a menudo se utilizan en entornos peligrosos.
Tipos de sensores de temperatura
No existe un sensor de temperatura universal para cada tipo de aplicación. Más bien, hay una extensa variedad de métodos y formas desde la cuales podemos medir el calor, tal como se citó más arriba. Las dos variantes más amplias son los sensores de temperatura de contacto y sin contacto.
Sensor de temperatura termopar
El sensor de temperatura por termopar se compone básicamente de dos tiras de metal o dos alambres hechos de metales diferentes y unidos en un extremo.
Los cambios en la temperatura en esa unión termopar inducen un voltaje en los extremos. A medida que la temperatura sube, el voltaje aumenta. Son muy económicos de fabricar y bastante fiables, pero no son muy precisos.
Sensor de temperatura por resistencia
El sensor de temperatura por resistencia se basa en materiales que varían su resistencia eléctrica al cambiar su temperatura.
Existen dos tipos de sensores con estas características, los dispositivos metálicos (RTD Resistance Temperature Detector) y los termistores.
En los RTD la resistencia del metal aumenta en forma más o menos lineal con la temperatura. De esta forma, se pueden considerar termoresistores PTC (Positive Temperature Coefficient – Coeficiente de Temperatura Positivo).
Por otro lado, los termistores se basan en semiconductores cerámicos. La resistencia disminuye en forma no lineal con el aumento en la temperatura. Estos se pueden considerar termoresistores NTC (Negative Temperature Coefficient – Coeficiente de Temperatura Negativo).
Sensor de temperatura bimetálico
El sensor de temperatura bimetálico es también conocidos como termostato. Son básicamente interruptores que producen una salida del tipo on-off y cambian de un estado al otro cuando se alcanza un determinado valor de temperatura.
Constan generalmente de un bimetal, esto es, una pieza formada por dos metales con distinto coeficiente de dilatación térmica.
Cuando se calientan, un lado se dilatará más que el otro, y la curvatura resultante se traduce en un movimiento mecánico, que puede ser usado para medir la temperatura mediante un indicador o para accionar un interruptor.
Estos sensores no requieren de una fuente de alimentación, y no son tan sensibles como los termopares o RTD.
Sensor de temperatura por dilatación de fluido
Un sensor por dilatación de fluido, es por ejemplo, el termómetro doméstico. Estos usan un líquido (generalmente mercurio) o gas que se contrae o expande con la variación de la temperatura.
Los sensores de dilatación de fluido no requieren energía eléctrica, y son estables. Por otra parte, no generan datos que se puedan registrar o transmitir fácilmente en forma digital.
Sensor de temperatura por infrarrojos o piro eléctricos
Un sensor de temperatura por infrarrojos (IR), denominados también pirómetros de radiación, son dispositivos que miden en forma indirecta la temperatura de cuerpos calientes a partir de la radiación térmica emitida en forma natural por los mismos.
Se utilizan en los casos en los cuales resulta imposible o peligroso el uso de sensores por contacto.
Sensor de temperatura monolíticos o de silicio
El sensor de temperatura monolítico es un dispositivo basado en las propiedades térmicas de las uniones semiconductoras (union PN), particularmente la dependencia de la tensión base emisor (VBE) de los transistores bipolares con la temperatura cuando la corriente de colector es constante.
Generalmente incluyen sus propios circuitos de procesamiento de señales, así como varias funciones de interface especiales con el mundo externo.
Modelos de sensores de temperatura
A continuación, veremos una lista de los sensores de temperatura más populares para el desarrollo de proyectos y prototipos con la placa Arduino. Estos sensores son excelentes para casi cualquier proyecto, ya que la mayoría de ellos son fáciles de usar y también son muy asequibles.
Sensor de temperatura y humedad DHT11
El sensor de temperatura DHT11 además de leer la temperatura, también lee la humedad.
Es una buena opción por su bajo costo. Su único inconveniente es que solo puede leer la señal digital una vez cada 1 segundo.
Características:
- Rango de voltaje desde 3 V a 5 V
- Rango de medición de temperatura desde 0°C a 50 °C
- Precisión de medición de temperatura de ±2.0 °C
- Resolución Temperatura: de 0.1°C
- Rango de medición de humedad desde 20% a 90% RH
- Precisión de medición de humedad de 4% RH
- Resolución humedad de 1% RH
- Tiempo de sensado de 1 seg
Sensor de temperatura y humedad DHT22
El sensor de temperatura DHT22 es muy similar en apariencia y funcionalidad al sensor de temperatura DHT11 ya que también mide la temperatura y la humedad.
Es un poco más costoso, pero es más preciso. Su punto negativo es que su velocidad de lectura es más lenta que el DHT11, solo puede leer la señal digital una vez cada 2 segundos.
Características:
- Rango de voltaje de 3.3V a 6V
- Rango de medición de temperatura de -40°C a 80 °C
- Precisión de medición de temperatura de <±0.5 °C
- Resolución Temperatura de 0.1°C
- Rango de medición de humedad desde 0 a 100% RH
- Precisión de medición de humedad de 2% RH
- Resolución humedad de 0.1%RH
- Tiempo de sensado de 2s
Sensor de temperatura LM32DZ
El sensor de temperatura LM35DZ es un sensor de tipo analógico, y viene directamente calibrado en grados Celsius.
La salida analógica en voltaje es directamente proporcional a la temperatura.
Características:
- Calibrado en grados Celsius
- Bajo consumo
- Factor de lectura lineal 10 mV/°C
- Precisión del 0.5°C
- Rango de lectura de ?55°C a +150°C
- Ideal para aplicaciones remotas
- Voltaje de funcionamiento desde 4 V a 30 V
Sensor de temperatura TMP36
El sensor de temperatura TMP36 es un sensor de tipo analógico, muy similar al sensor de temperatura LM35.
Al igual que el sensor anterior, su salida analógica de voltaje es proporcional a la temperatura ambiente.
Características:
- Voltaje de funcionamiento de 2.7 V a 5.5 V
- Calibrado directamente en °C
- Factor de escala de 10 mV/°C
- Precisión de ±2°C, linealidad de ±0.5°C
- Stable with large capacitive loads
- Rango de operación de ?40°C to +125°C
- Bajo consumo
Sensor de temperatura LM75
El sensor de temperatura LM75, además de ser igual de practico y preciso que los anteriores, funciona mediante el bus I2C.
La gran ventaja de que sea un sensor completamente digital es su mayor inmunidad al ruido, ya que toda la electrónica de adquisición y conversión está integrada.
Características:
- Interface de bus I2C para un máximo de 8 dispositivos en el bus
- Rango de voltaje desde 2.8 V a 5.5 V
- Rango de temperatura desde ?55°C a +125°C
- ADC interno de 11-bit con resolución de 0.125°C
- Precisión de ±2°C desde ?25°C a +100°C, ±3°C desde ?55°C a +125°C
- Bajo consumo
Sensor de temperatura TMP100
El sensor de temperatura TMP100 al igual que el anterior usa el bus I2C, pero con la diferencia de que tiene dos pines de dirección, lo que permite controlar hasta ocho sensores diferentes usando un solo bus I2C.
Es una solución ideal para el caso en que se desee hacer mediciones de temperatura en diferentes puntos y se desea usar un cableado simple.
Características:
- Interface bus I2C, para un máximo de 8 dispositivos en el bus
- Rango de voltaje desde 2.7V a 5.5V
- Resolución ajustable de 9 a 12 bits
- Precisión de ±2ºC desde –25ºC a +85ºC, ±3ºC desde –55ºC a +125ºC
- Bajo Consumo
Sensor de temperatura DS18B20
El sensor de temperatura DS18B20 tiene como característica que para comunicarse utiliza el protocolo 1-Wire, esto significa que se comunica usando solo un pin.
Cada sensor tiene un número de serie único, lo que permite conectar más de un DS18B20 en el mismo bus de datos sin interferencia alguna.
Características:
- Interfaz 1-Wire, múltiples sensores pueden compartir el mismo pin
- Rango de voltaje desde 3.0V a 5.5V
- Rango de temperatura de -55 a 125°C
- Resolución ajustable de 9 a 12 bits
- Identificador interno único de 64 bits
- Precisión de ±0.5°C desde -10°C a +85°C
- Tiempo de captura inferior a 750ms
Sensor de temperatura y presión barométrica BMP180
El sensor de temperatura y presión barométrica BMP180 es un dispositivo algo más avanzado. Es un sensor de bus I2C que combina lecturas de presión barométrica y de temperatura.
Con estos dos valores de lectura, y mediante un poco de programación, también permite inferir la altura. Es un sensor bastante económico y muy usado en proyectos de estaciones meteorológicas.
Características:
- Interfaz bus I2C
- Rango de voltaje de 3.3V a 5V
- Rango de Presión barométrica desde 300 a 1100 hPa
- Resolución barométrica de 1 Pa
- Precisión barométrica absoluta de 1 hPa
- Resolución de temperatura de 0.1°C
- Precisión Temperatura de 1°C
- Frecuencia de Muestreo de 120Hz
- Consumo de energía ultra bajo
- Completamente calibrado
¿Qué modelo de sensor de temperatura debo elegir?
El modelo de sensor de temperatura a elegir para nuestro proyecto dependerá mucho del entorno en donde va a funcionar y de su aplicación final.
Si lo que deseamos es hacer solo medición de temperatura en un ambiente cerrado, como una habitación, todos los sensores arriba descritos pueden servir sin problemas.
Si lo que deseamos es medir temperatura en exteriores los sensores DHT11, DHT22 y BMP180 no son recomendables por no tener protección a la intemperie. Es posible usarlos con algún tipo de encapsulado de protección, pero es necesario garantizar la libre circulación de aire para evitar lecturas erróneas.
Por otro lado, si deseamos medir temperatura en líquidos, el sensor DS18B20 es el ideal, pero debe cuidarse que sus contactos eléctricos estén protegidos contra la humedad.
Finalmente, si deseamos algo más cercano a una estación meteorológica, el sensor BMP180 es el ideal, ya que además de medir la temperatura, puede medir la presión barometrica. Si este sensor se va a usar en exteriores, es conveniente colocarlo dentro de alguna capsula protectora con libre circulación de aire.
¿Cómo puedo medir la temperatura?
La forma en que se puede leer el valor de un sensor de temperatura con nuestra placa Arduino dependerá del tipo de interfaz hardware que necesite el sensor, esto es, si es un sensor analógico usaremos una entrada ADC, si es un sensor de bus serie podemos usaremos el bus I2C o el bus 1-Wire.
Ejemplos de programación para medir la temperatura
Para culminar esta publicación, veremos los ejemplos de programación para cada uno de los sensores anteriormente descritos. Se busca explicar con ejemplos sencillos como configurar y leer estos sensores, de forma que puedas integrar con mucha facilidad el código en tus proyectos.
Todos los ejemplos han sido desarrolados en el Arduino IDE usando una placa Arduino UNO R3, pero pueden ser facilmente adaptados para otras placas, como la Arduino Mega 2560 o la Arduino Pro Mini.
Programación para los sensores de temperatura DHT11 y DHT22
Si bien, ambos sensores tienen algunas diferencias, el programa para leer los datos de estos es prácticamente el mismo. Solo se debe tomar en consideración algún pequeño ajuste para que funcione con ambos.
A nivel de circuito esquemático, las conexiones son exactamente las mismas, que para nuestro ejemplo se harán sobre una placa Arduino UNO R3.
Para que el programa funcione, es necesario que descargues las librerías DHT Sensor y Adafruit Sensor de Adafruit. Estas librerías debes instalarlas en el directorio Libraries de tu instalación de Arduino IDE.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
/* * Lector de temperatura para los sensores DHT11 y DHT22 * * https://www.proyectoarduino.com * */ #include "DHT.h" #include <Adafruit_Sensor.h> // El sensor esta conectado al pin D2 const int dht_pin = 2; // Selecciona el tipo de sensor: 1 para DHT11, 0 para DHT22 #if 1 const int dht_tipo = DHT11; #else const int dht_tipo = DHT22; #endif float dht_humedad; float dht_temperatura; DHT dht(dht_pin, dht_tipo); void setup() { // Inicializa puerto serie Serial.begin(9600); // Inicializa sensor dht.begin(); } void loop() { // Espera 2 segundos para que finalice la conversion delay(2000); // Lee los valores de humedad y temperatura float dht_humedad = dht.readHumidity(); float dht_temperatura = dht.readTemperature(); // Envia las lecturas al monitor serial Serial.print("Humedad "); Serial.print(dht_humedad); Serial.println(" %"); Serial.print("Temperatura: "); Serial.print(dht_temperatura); Serial.println("ºC"); } |
Programación para los sensores de temperatura LM32DZ y TMP36
Al igual que el caso anterior, la programación para estos dos sensores es prácticamente la misma. La única salvedad es tener en cuenta el desplazamiento (offset) de la medida de temperatura de cada uno. A nivel de pines, la disposición es la misma para ambos.
Para ambos sensores la salida de tensión será de 10 mV/ºC. El convertidor ADC de la placa Arduino tiene una resolución de 10 bits, lo que nos da un rango de lectura de 0 a 1023, que por lo general la referencia de voltaje por defecto de la placa asocia 0 con GND y 1023 con 5 V. En base a esto, la lectura en ºC del sensor será:
Temperatura = 5 * Vs * 100 / 1024
En donde Vs es el voltaje de salida del sensor. La ecuación anterior es válida para el sensor LM32DZ. Para el sensor TMP36 hay que hacer una modificación que consiste en restar el valor de desplazamiento debido al rango de lectura.
Temperatura = (5 * Vs * 100 / 1024) – 50
Para el sensor LM32DZ cero voltios (GND) es 0ºC, mientras que para el sensor TMP36 cero voltios es -50ºC.
A nivel de circuito esquemático las conexiones son exactamente las mismas.
En el codigo se introduce una clausula #if que selecciona de acuerdo a su valor que sensor se va a usar. Para nuestro caso #if 1 es el sensor LM32DZ e #if 0 es el sensor TMP36.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
/* * Lector de temperatura para los sensores TMP36 y LM35DZ * * https://www.proyectoarduino.com * */ // Sensor de temperatura conectado a pin ADC A0 int sensor_adc = 0 ; int sensor_lectura; float temperatura; // Seleccion de sensor: 1 -> LM35DZ, 0 -> TMP36 #if 1 int sensor_offset = 0; #else int sensor_offset = 50; #endif void setup(){ // Inicializa puerto serie Serial.begin(9600); } void loop(){ // Lee el sensor sensor_lectura = analogRead(sensor_adc); // Convierte la lectura cruda en valor de temperatura temperatura = (5.0 * sensor_lectura / 1024) * 100 - sensor_offset; // Envia la temperatura al monitor serie Serial.print(temperatura) ; Serial.println("ºC") ; // Espera 5 segundos para la siguiente lectura delay(5000); } |
Programación para los sensores de temperatura LM75 y TMP100
Para este ejemplo agrupamos estos dos sensores de temperatura ya que ambos usan el mismo interfaz de comunicaciones, el bus I2C.
Por otro lado, aunque usen el mismo bus de comunicaciones, no quiere decir que se puedan usar de la misma forma.
Para el caso del sensor de temperatura LM75, dado que es un chip muy pequeño y algo difícil de manejar, se usa una tarjeta de montaje (breakout board) que contiene el chip LM75 y las resistencias de pull-up necesarias para activar el bus I2C.
El circuito esquemático de esta tarjeta es el siguiente
Gracias a esta tarjeta, el cableado con la placa Arduino UNO R3 es bastante sencillo
La programación del sensor LM75 es bastante sencilla. Solo es necesario establecer la dirección que le corresponde en el bus I2C.
La dirección de bus I2C del sensor se representa en el programa en binario, y es 0B01001XXX. Los últimos 3 bits determinan la dirección del dispositivo en sus líneas de dirección A0, A1 y A2, que para el caso de la tarjeta al no estar conectados están en 000.
Si se desea cambiar esta dirección, es necesario cambiar el estado de los pines A0, A1 y A2 a nivel alto (valor uno) o nivel bajo (valor cero).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
/* * Lector de temperatura para sensor LM75 * * https://www.proyectoarduino.com * */ #include <Wire.h> // Dirección I2C del sensor LM75 con A0, A1 y A2 a nivel bajo (ultimos 3 bits) const int lm75_direccion = 0B01001000; // Registro de solicitud de lectura de la temperatura const int lm75_lectura = 0; // Almacen de la temperatura leida int lm75_temperatura; void setup(){ // Inicializa el puerto serie Serial.begin(9600); // Inicializa el bus I2C Wire.begin(); } void loop(){ // Inicia comunicacion con el sensor Wire.beginTransmission(lm75_direccion); // Solicita leer la temperatura Wire.write(lm75_lectura); // Termina la comunicacion Wire.endTransmission(); // Inicia comunicaciones con el sensor y solicita leer 2 bytes Wire.requestFrom(lm75_direccion,2); // Leer el primer byte, desplaza 8 posiciones, añade el segundo byte lm75_temperatura=(Wire.read()<<8) | Wire.read(); // Termina la comunicacion Wire.endTransmission(); // Envia a la consola la lectura de la temperatura Serial.print((float)(lm75_temperatura/256), DEC); Serial.println("ºC"); // Espera 5 segundos para hacer una nueva lectura delay(5000); } |
Para el caso del sensor TMP100, usamos para el ejemplo una tarjeta de montaje (breakout board) de Sparkfun que es más cómoda de usar y tiene todo lo necesario para conectarla a nuestra placa Arduino.
De esta manera, las conexiones se simplifican
Como se comentó anteriormente, aunque el sensor TMP100 usa el bus I2C al igual que el sensor LM75, la configuración y lectura de la temperatura se efectúa de manera diferente.
El sensor TMP100 usa dos pines para determinar la dirección de bus I2C, ADD0 y ADD1.
Con estos dos pines es posible definir hasta 8 direcciones diferentes. Pero ¿Cómo es posible hacer eso con solo 2 bits?
Este sensor tiene la particularidad de usar un tercer estado para definir las direcciones. Esto quiere decir que cada pin reconoce tres posibles estados: GND, flotante (no conectado) y Vcc.
Esto se verá más claramente en la siguiente tabla.
| ADD1 | ADD0 | DIRECCION I2C |
| GND | GND | 1001000 |
| GND | Flotante (no conectado) | 1001001 |
| GND | VCC | 1001010 |
| VCC | GND | 1001100 |
| VCC | Flotante (no conectado) | 1001101 |
| VCC | VCC | 1001110 |
| Flotante (no conectado) | GND | 1001011 |
| Flotante (no conectado) | VCC | 1001111 |
Para el caso de la tarjeta de montaje de Sparkfun, la dirección prefijada es 0B1001111 que corresponde con 0x4f HEX.
El programa, salvo los cambios necesarios, hace exactamente lo mismo que la versión del sensor LM75.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
/* * Lector de temperatura para sensor TMP100 * * https://www.proyectoarduino.com * */ #include<Wire.h> // Direccion del en el bus I2C del sensor TMP100 const int tmp100_direccion = 0x4f; const int tmp100_reg_datos = 0x00; const int tmp100_reg_configuracion = 0x01; const int tmp100_modo_conversion_continua = 0x60; unsigned int tmp100_datos[2]; float tmp100_temperatura; void setup(){ // Inicializa puerto serie Serial.begin(9600); // Inicializa bus I2C Wire.begin(); // Inicia comunicaciones con el sensor Wire.beginTransmission(tmp100_direccion); // Selecciona el registro de configuracion Wire.write(tmp100_reg_configuracion); // Selecciona conversion continua, modo comparacion, 12 bits de resolucion Wire.write(tmp100_modo_conversion_continua); // Finaliza comunicaciones Wire.endTransmission(); delay(500); } void loop(){ // Inicia comunicaciones con el sensor Wire.beginTransmission(tmp100_direccion); // Selecciona el registro de datos Wire.write(tmp100_reg_datos); // Finaliza comunicaciones Wire.endTransmission(); // Solicita leer dos registros de datos Wire.requestFrom(tmp100_direccion, 2); // La lectura es de 12 bits, un byte bajo con 8 bits // y un byte alto con 4 bits if(Wire.available() == 2) { tmp100_datos[0] = Wire.read(); tmp100_datos[1] = Wire.read(); } // Convierte los datos a temperatura en grados Celsius tmp100_temperatura = (((tmp100_datos[0] * 256) + (tmp100_datos[1] & 0xf0)) / 16) * 0.0625; // Envia la temperatura leida al monitor serial Serial.print(tmp100_temperatura); Serial.println("ºC"); // Espera 5 segundos para hacer una nueva lectura delay(5000); } |
Programación para el sensor de temperatura DS18B20
El DS18B20 es un sensor de temperatura digital que se comunica usando el protocolo 1-Wire. Este protocolo necesita solo un pin de comunicaciones para el intercambio bidireccional de datos, y dado que cada dispositivo tiene su propio número de serie, permite conectar más de un sensor en el mismo bus.
La versión más popular de este sensor usa el encapsulado TO-92, similar al empleado en pequeños transistores. Esta es la versión más usada para pruebas y desarrollos en ambientes secos. Existe otra presentación de este sensor que se usa para ser sumergida en líquidos.
El protocolo 1-Wire usado por este sensor solo necesita dos líneas de conexión, una a GND, y otra compartida Vcc/datos. Esta debe tener una resistencia pull-up hacia Vcc.
Gracias a esta forma de funcionar, la conexión hacia el microcontrolador es muy simple
Los dispositivos 1-Wire pueden funcionar con o sin fuente de alimentación. Si se desea usar alimentación externa, generalmente por cuestiones de estabilidad o precisión en las lecturas, esta debe conectarse al pin VDD.
Si no se va a usar fuente de alimentación externa, la línea VDD debe conectarse con GND. De esta forma se activa en el dispositivo la modalidad parasite power.
De esta forma, el sensor internamente obtiene energía del pin de datos cuando este se encuentra en un estado alto, almacenando la carga en un condensador interno, del cual obtendrá energía cuando la línea de datos esté en un nivel bajo.
EL transistor MOSFET que aparece en el circuito hace la función de fuente de corriente, y es una ayuda para mantener más estable el voltaje de alimentación del sensor, pero no es necesario si la línea de datos entrega suficiente corriente.
Para poder programar el sensor DS18B20 en la placa Arduino necesitamos dos librerías. Una es la librería OneWire que implementa el protocolo del bus 1-Wire por software.
La otra librería necesaria es la DallasTemperature, que implementa las funciones necesarias para poder controlar el sensor DS18B20.
Para instalar las librerías en Arduino IDE puede hacerlo, o bien descargando cada una y copiándolas en el directorio Libraries, o en el menú del IDE Programa->Include Library->Manage Library y buscar las librerías OneWire y DallasTemperature.
La conexión del sensor con la placa Arduino es bastante simple. Además del sensor, se necesita una resistencia de 4.7kOhm conectada entre la línea de datos y Vcc.
Al igual que en los casos anteriores, el programa inicializa el sensor para proceder a enviarle ordenes de conversión y leer la temperatura, y el puerto serie para su posterior envío de resultados al monitor serie en el Arduino IDE.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
/* * Lector de temperatura para sensor DS18B20 * * https://www.proyectoarduino.com * */ #include <OneWire.h> #include <DallasTemperature.h> // Bus 1-Wire en pin D9 const int ds18b20_pin = 9; // Inicia los manejadores para el bus 1-Wire y el sensor OneWire ds18b20_oneWire(ds18b20_pin); DallasTemperature ds18b20_sensor(&ds18b20_oneWire); void setup() { // Inicializa el puerto serie Serial.begin(9600); // Inicializa el bus 1-Wire ds18b20_sensor.begin(); } void loop() { // Envia la orden al sensor para que capture la temperatura ds18b20_sensor.requestTemperatures(); // Lee la temperatura capturada // y envia el resultado el monitor serie Serial.print(ds18b20_sensor.getTempCByIndex(0)); Serial.println("ºC"); // Espera 5 segundos antes de hacer una nueva lectura delay(5000); } |
Programación para el sensor de temperatura y presión barométrica BMP180
Se ha dejado para el final uno de los sensores más versátiles dentro de los descritos más arriba, el BMP180.
El BMP180 es un sensor que combina un barómetro y un termómetro, ambos digitales. La función principal del BMP180 es leer la presión atmosférica, e incorpora el termómetro para compensar la variación de esta, ya que la densidad del aire varia con la temperatura.
Hay otros factores que influyen en la medición de la presión atmosférica, como la humedad relativa y la altitud. Este último factor, la altitud, se puede determinar indirectamente usando varias medidas de la presión atmosférica a varias alturas, estableciendo un marco de referencia. Por ejemplo, se puede hacer una medida inicial de la presión a nivel de suelo (esta sería la referencia), y a partir de allí, haciendo medidas regulares de la presión atmosférica se puede inferir la altura.
Este es uno de los métodos usados en los drones y aeromodelos para calcular su altura de vuelo. No es muy preciso, pero si lo bastante aproximado.
El sensor BMP180 es muy económico dada su versatilidad, y es la elección ideal para casi cualquier tipo de proyecto en que desees leer la temperatura, y como adicional, la presión atmosférica, lo que convierte tu diseño en una pequeña estación meteorológica.
La forma más cómoda de usar este sensor es adquiriendo algunos de los breakout boards existentes en el mercado.
No importa mucho la forma física, lo único que importa es que tengan al menos las cuatro conexiones necesarias: VCC, GND, SDA y SCL.
La forma de conexión de este sensor a la placa Arduino UNO R3 es de lo más simple, gracias al uso del bus I2C. En lo único en que se debe tener cuidado es en el voltaje de alimentación. Este sensor funciona con 3.3.V y no toleran voltajes de 5V. Es recomendable que adquieras uno que tenga regulador LDO de 5V a 3.3v incorporado. Si ya posees uno de 3.3V debes conectarlo a pin 3V3 de la placa Arduino, NO AL PIN 5V.
A nivel de programación, se deben usar una librería para simplificar la configuración y manejo del sensor. Las dos librerías más populares son las de Sparkfun y Adafruit. Veremos ejemplos de lecturas de temperatura, presión atmosférica y cálculo de altitud para cada librería.
Versión para la librería de Sparkfun
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 |
/* * Lector de temperatura, presión atmosférica y altitud * para sensor BMP180 usando la librería de Sparkfun * * https://www.proyectoarduino.com * */ #include <SFE_BMP180.h> #include <Wire.h> char sensor_bmp180_status; double sensor_bmp180_temperatura; double sensor_bmp180_presion; double sensor_bmp180_altitud; SFE_BMP180 sensor_bmp180; // Presión sobre el nivel del mar en mbar // Este valor debe ser cambiado por la presión en el sitio // en donde está el sensor para mayor precisión const double sensor_bmp180_presion_base = 1013.25; void setup(){ // Inicializa el puerto serie Serial.begin(9600); // Verificamos si el sensor está conectado y configurado if (sensor_bmp180.begin()) Serial.println("Sensor BMP180 iniciado!"); else { Serial.println("Error al iniciar el sensor BMP180"); while(1); } } void loop(){ // Lee la temperatura sensor_bmp180_status = sensor_bmp180.startTemperature(); // Verifica si el sensor ha respondido if (sensor_bmp180_status != 0) { // Tiempo de espera para que el sensor termine la conversión delay(sensor_bmp180_status); // Lee la temperatura sensor_bmp180_status = sensor_bmp180.getTemperature(sensor_bmp180_temperatura); // Si la lectura ha sido correcta, se lee la presión atmosférica if (sensor_bmp180_status != 0) { // Lectura de la presión sensor_bmp180_status = sensor_bmp180.startPressure(3); // Verifica si el sensor ha respondido if (sensor_bmp180_status != 0) { // Tiempo de espera para que el sensor termine la conversión delay(sensor_bmp180_status); // Lee la presión aplicando la compensación por temperatura sensor_bmp180_status = sensor_bmp180.getPressure(sensor_bmp180_presion, sensor_bmp180_temperatura); // Si la lectura ha sido correcta, se envían las lecturas al monitor serie if (sensor_bmp180_status != 0) { sensor_bmp180_altitud = sensor_bmp180.altitude(sensor_bmp180_presion, sensor_bmp180_presion_base); Serial.print(sensor_bmp180_temperatura,2); Serial.print("ºC , "); Serial.print(sensor_bmp180_presion,2); Serial.print(" mb, "); Serial.print(sensor_bmp180_altitud); Serial.println(" metros."); } } } } // Espera 5 segundos para la próxima lectura delay(5000); } |
Versión para la librería de Adafruit
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
/* * Lector de temperatura, presión atmosférica y altitud * para sensor BMP180 usando la librería de Adafruit * * https://www.proyectoarduino.com * */ #include <Wire.h> #include <Adafruit_BMP085.h> Adafruit_BMP085 sensor_bmp180; void setup() { // Inicializa puerto serie Serial.begin(9600); // Inicializa y verifica si el sensor está conectado if (sensor_bmp180.begin()) { Serial.println("Sensor BMP180 iniciado!"); } else { Serial.println("Error al iniciar sensor BMP180"); while (1) {} } } void loop() { // Envia al monitor serie los valores de temperatura y presión atmosférica Serial.print(sensor_bmp180.readTemperature()); Serial.println("ºC, "); Serial.print(sensor_bmp180.readPressure()); Serial.println(" Pa"); // Para calcular la altura, asumimos una presión barométrica // "normal" de 1013.25 millibar = 101325 Pascal // Si se desea mayor precisión, se debe sustituir el valor "normal" // por el valor "real" en donde está localizado el sensor Serial.print("Altitud = "); Serial.print(sensor_bmp180.readAltitude(101325)); Serial.println(" metros"); // Espera 5 segundos para una nueva lectura delay(500); } |
