Termómetro Arduino Grados Centigrados °C Kelvin Farenheit con sensor LM35 y display LCD 16x2

¡Bienvenido a este tutorial! Hoy aprenderemos cómo construir un termómetro digital utilizando un sensor de temperatura LM35 con un display LCD 16x2 con Arduino. Este proyecto te permitirá medir la temperatura en Celsius, Kelvin y Fahrenheit, mostrando los resultados de manera clara y fácil de interpretar. 

La medición de la temperatura es fundamental en diversas aplicaciones, desde sistemas domésticos, como control de clima, hasta proyectos industriales. Entender cómo funciona y cómo implementar un termómetro digital es un excelente paso para adentrarte en el mundo de la electrónica y la programación.

Escalas de Temperatura

Antes de empezar, repasemos brevemente las escalas de temperatura que usaremos:

• Celsius (°C): Es la escala más utilizada en el mundo y está basada en los puntos de congelación (0 °C) y ebullición (100 °C) del agua.
• Kelvin (K): Escala utilizada en ciencia, donde 0 K representa el cero absoluto, el punto más bajo posible de energía térmica.
• Fahrenheit (°F): Común en países como Estados Unidos, tiene un rango diferente al de Celsius, siendo su punto de congelación a 32 °F y de ebullición a 212 °F.

¿Qué es el sensor LM35?

El LM35 es un sensor de temperatura analógico muy popular. Algunas de sus características principales son:

• Alta precisión: ±0.5 °C a temperatura ambiente.
• Rango de medición: -55 °C a 150 °C.
• Proporciona una salida lineal de voltaje: 10 mV por °C.
• Fácil de usar, ya que no requiere calibración externa.

¿Qué es el display LCD 16x2?

El LCD 16x2 es un dispositivo que permite mostrar información en 2 líneas de 16 caracteres cada una. Es ideal para visualizar datos como temperaturas, fechas o cualquier información en proyectos Arduino. Se conecta fácilmente mediante 6 pines al microcontrolador y funciona con librerías de Arduino como LiquidCrystal.

Primero haremos el ejemplo para medir y mostrar la temperatura en °C, K y °F utilizando el LM35 y el LCD 16x2:

Esquema de conexión en Arduino UNO:

Materiales:

1. Arduino Uno (o similar)
2. Sensor LM35
3. Display LCD 16x2 con módulo I2C
4. Protoboard
5. Cables de conexión

Conexiones:

1. Sensor LM35:

   • VCC (Pin 1): Conéctalo a 5V del Arduino.
   • Salida (Pin 2): Conéctalo al pin analógico A0 del Arduino.
   • GND (Pin 3): Conéctalo a GND del Arduino.

2. Display LCD 16x2 con módulo I2C:

   • VCC: Conéctalo a 5V del Arduino.
   • GND: Conéctalo a GND del Arduino.
   • SDA: Conéctalo al pin A4 del Arduino Uno (o al pin etiquetado como SDA en placas como el Mega o Nano).
   • SCL: Conéctalo al pin A5 del Arduino Uno (o al pin etiquetado como SCL en placas como el Mega o Nano).

Configuración del código:

Recuerda que al usar un módulo I2C, necesitarás la librería LiquidCrystal_I2C. Puedes instalarla desde el Administrador de Librerías en Arduino IDE o también a continuación te facilitamos el enlace para que descargues la librería:

 https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library

Código para Arduino:

 #include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Configuración del LCD con dirección I2C (generalmente es 0x27 o 0x3F)
LiquidCrystal_I2C lcd(0x27, 16, 2);

// Pin del sensor LM35
const int sensorPin = A0;

void setup() {
lcd.init(); // Inicializar el LCD
lcd.backlight(); // Encender la retroiluminación
lcd.print("Termometro"); // Mensaje de bienvenida
delay(2000);
lcd.clear(); // Limpiar la pantalla
}

void loop() {
int lectura = analogRead(sensorPin); // Leer el sensor LM35
float voltaje = lectura * (5.0 / 1023.0); // Convertir lectura a voltaje
float tempC = voltaje * 100; // Convertir voltaje a °C
float tempK = tempC + 273.15; // Convertir °C a Kelvin
float tempF = (tempC * 9 / 5) + 32; // Convertir °C a °F

// Mostrar la temperatura en el LCD
lcd.setCursor(0, 0); // Primera línea
lcd.print("C:");
lcd.print(tempC, 1); // Mostrar 1 decimal
lcd.print(" K:");
lcd.print(tempK, 1);

lcd.setCursor(0, 1); // Segunda línea
lcd.print("F:");
lcd.print(tempF, 1);

delay(1000); // Actualizar cada segundo
}

Explicación del Código

Este código implementa un termómetro digital que mide la temperatura en Celsius (°C), Kelvin (K) y Fahrenheit (°F) utilizando un sensor LM35 y muestra los valores en un display LCD 16x2 con módulo I2C.

1. Librerías Importadas

• Wire.h: Permite la comunicación I2C entre el Arduino y el módulo del LCD.
• LiquidCrystal_I2C.h: Facilita la interacción con pantallas LCD que usan un módulo I2C.

2. Configuración del LCD

• 0x27: Dirección I2C del LCD (puede ser diferente, como 0x3F; utiliza un escáner I2C si no funciona).
• 16, 2: Define que el LCD tiene 16 columnas y 2 filas.

3. Definición del Pin del Sensor

• Declara que el LM35 está conectado al pin analógico A0.

4. Configuración Inicial (setup)

• Inicializa el LCD, enciende la retroiluminación y muestra un mensaje introductorio.

5. Bucle Principal (loop)

a) Lectura del Sensor

• analogRead(sensorPin): Obtiene un valor entre 0 y 1023 dependiendo del voltaje proporcionado por el sensor LM35.

b) Conversión del Valor Analógico

• La fórmula convierte el valor analógico en voltaje: $$\text{Voltaje} = \text{lectura} \times \frac{5.0}{1023.0}$$
• El voltaje resultante se multiplica por 100 (es la relación del LM35) para obtener la temperatura en grados Celsius.

c) Conversión de Unidades

• Kelvin (K): Suma 273.15 al valor en °C.
• Fahrenheit (°F): Aplica la fórmula de conversión: $$\text{°F} = \text{°C} \times \frac{9}{5} + 32$$

d) Mostrar Datos en el LCD

• lcd.setCursor(x, y): Coloca el cursor en la posición (x, y):
  • x: Columna (0-15).
  • y: Fila (0-1).
• lcd.print(): Escribe texto o números en el LCD. El segundo argumento (1) limita los decimales mostrados.

e) Espera para Actualizar

• Pausa de 1 segundo antes de volver a leer el sensor y actualizar los datos.

Cuando subas el código al Arduino y realices las conexiones correctamente, el LCD mostrará un mensaje de bienvenida y luego comenzará a medir la temperatura en tiempo real usando el LM35. Verás en la pantalla las temperaturas en Celsius (°C), Kelvin (K) y Fahrenheit (°F) actualizadas cada segundo. Si tocas el sensor o lo expones a calor o frío, los valores cambiarán en consecuencia. Si algo falla, revisa las conexiones del LCD y del LM35, así como la dirección I2C.

¡Explora más opciones para medir temperatura!

Además del sensor LM35, existen otros sensores de temperatura que puedes usar en tus proyectos según tus necesidades específicas. Algunos de ellos son:

• DHT11 y DHT22: Sensores económicos que miden temperatura y humedad.

  • DHT11: Menor precisión, rango limitado (-20°C a 50°C).
  • DHT22: Mayor precisión, rango extendido (-40°C a 80°C).

• DS18B20: Sensor digital resistente al agua (opcional) ideal para medir temperaturas en líquidos y ambientes extremos (-55°C a 125°C).

• AHT21B: Sensor digital de alta precisión que mide temperatura y humedad. Compacto y fácil de usar con protocolos I2C.

• Módulo Sensor de Temperatura Digital: Módulo ofrecen una buena opción para medir temperaturas analógicas o digitales.

• Módulo MAX6675 + Termocupla Tipo K: Perfecto para medir temperaturas muy altas (hasta 1024°C) en procesos industriales.

• Resistencia Termistor NTC 47D-15: Termistor económico que cambia su resistencia en función de la temperatura, ideal para proyectos básicos de monitoreo.

¿Cuál sensor usar en tu próximo proyecto?

Selecciona el sensor que mejor se adapte según el rango de temperatura, la precisión requerida y el entorno de medición. ¡Explora estas opciones y lleva tus proyectos al siguiente nivel!

¡Simplifica tus proyectos con un display LCD I2C!

Si buscas una forma práctica y eficiente de mostrar información como temperatura, humedad u otros datos, el display LCD 16x2 con módulo I2C es la solución ideal.

• Ventajas del I2C: Reduce el número de pines necesarios (solo 2 pines, SDA y SCL).
• Fácil integración: Compatible con bibliotecas como LiquidCrystal_I2C para Arduino.

¡Contáctanos para más información sobre sensores, displays y módulos compatibles con tus proyectos electrónicos! 🚀