En este tutorial, aprenderás a usar un TMP36 sensor de temperatura analógico con Arduino. He incluido un diagrama de conexiones y varios códigos de ejemplo para ayudarte a empezar.
En la primera parte de este artículo, encontrarás las especificaciones e información sobre los sensores TMP35, TMP36 y TMP37. Luego, veremos cómo conectar el sensor al Arduino.
El primer ejemplo de código se puede usar para tomar lecturas de temperatura del sensor y mostrar los resultados en el Monitor Serial. En el segundo ejemplo, te mostraré cómo mostrar la temperatura en una pantalla LCD I2C para crear un termómetro independiente.
Materiales
Componentes de hardware
| TMP36 analog temperature sensor (TO-92) | × 1 | Amazon |
| Arduino Uno | × 1 | Amazon |
| Breadboard | × 1 | Amazon |
| Jumper wires | ~ 10 | Amazon |
| 16×2 character I2C LCD | × 1 | Amazon |
| USB cable type A/B | × 1 | Amazon |
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Acerca de los sensores de temperatura analógicos TMP35/TMP36/TMP37
Los TMP35/TMP36/TMP37 son sensores de temperatura centígrados de precisión y bajo voltaje fabricados por Analog Devices. Proporcionan una salida de voltaje linealmente proporcional a la temperatura en grados Celsius (°C) y, por lo tanto, son muy fáciles de usar con Arduino. Además, son precisos, no se desgastan y son muy económicos.
Los sensores TMP35/TMP36/TMP37 no requieren calibración externa para ofrecer una precisión típica de ±1°C a +25°C y ±2°C en el rango de temperatura de −40°C a +125°C.
La diferencia entre el TMP35, TMP36 y TMP37 es su rango de operación y el factor de escala de salida. El TMP35 mide temperaturas de 10°C a 125°C y proporciona una salida de 250 mV a 25°C. Este sensor es compatible funcionalmente con el LM35 de Texas Instruments. Consulta el LM35 analog temperature sensor with Arduino tutorial para más detalles.
El TMP36 mide temperaturas de -40°C a 125°C, proporciona una salida de 750 mV a 25°C y funciona hasta +125°C con una alimentación única de 2.7 V. Este sensor es compatible funcionalmente con el LM50. El TMP35 y TMP36 tienen el mismo factor de escala de salida de 10 mV/°C.
El TMP37 está diseñado para un rango operativo de 5°C a 100°C y proporciona una salida de 500 mV a 25°C. Este sensor ofrece una precisión ligeramente mayor que los otros y tiene un factor de escala de salida de 20 mV/°C.
Como puedes ver en la figura anterior, el rango de salida de todos los sensores está entre 0.1 V y 2 V. Ten en cuenta que el voltaje de salida es independiente del voltaje de alimentación que uses.
Pinout del TMP35/TMP36/TMP37
Los sensores TMP35/TMP36/TMP37 vienen en 3 formatos diferentes, pero el tipo más común es el 3-pin TO-92 paquete TO-92, que se parece a un transistor. La versión TMP36 de este sensor tiene el número de modelo TMP36GT9Z.
El pinout del sensor se muestra en la figura a continuación:
Ten en cuenta que el pin 1 (+V S ) es el pin más a la izquierda cuando el lado plano del sensor (con el texto impreso) está frente a ti.
Puedes encontrar más especificaciones del TMP36 en la tabla a continuación.
Especificaciones del sensor de temperatura analógico TMP36
| Voltaje de alimentación | 2.7 V a 5.5 V |
| Corriente en reposo | 50 µA |
| Rango de temperatura | -40°C a +125°C |
| Precisión | ±1°C a +25°C ±2°C de -40°C a +125°C |
| Factor de escala de salida | 10 mV/°C |
| Voltaje de salida a 25°C | 750 mV |
| Paquete | TO-92 de 3 pines |
| Fabricante | Analog Devices |
| Costo | Check price |
Para más información, también puedes consultar la hoja de datos aquí:
Conexiones – Cómo conectar el sensor de temperatura TMP36 al Arduino
Conectar un TMP36 al Arduino es muy fácil, solo necesitas conectar 3 pines. Comienza conectando el pin +V S al pin de 5 V del Arduino y el pin GND a tierra. Si usas un Arduino de 3.3 V, simplemente conecta +V S a 3.3 V en su lugar.
Luego, conecta el pin central (V OUT ) a cualquiera de las entradas analógicas del Arduino. En este caso, usé el pin analógico A0.
Las conexiones también se muestran en la tabla a continuación:
Conexiones del sensor de temperatura analógico TMP36
| TMP36 | Arduino |
|---|---|
| Pin 1 (+V S ) | 5 V |
| Pin 2 (V OUT ) | Pin A0 |
| Pin 3 (GND) | GND |
Para mejorar la estabilidad del sensor, la hoja de datos recomienda añadir un condensador cerámico de 0.1 μF entre el pin +V S y GND. Cuando uses cables largos, añadir una pequeña resistencia (por ejemplo, 750 Ω) en serie con la línea de señal (V OUT ) también puede reducir el ruido.
Cuando probé el sensor con un Arduino Uno, obtuve lecturas estables sin el condensador ni la resistencia, pero tus resultados pueden variar.
Convertir el voltaje de salida del TMP36 en temperatura
Para convertir el voltaje de salida del sensor en temperatura en grados Celsius, puedes usar la siguiente fórmula:
Temperatura (°C) = (V OUT – 500) / 10
con V OUT en milivoltios (mV). Así que si la salida del sensor es 750 mV, la temperatura es:
(750 – 500) / 10 = 25°C
Como ves en el diagrama de conexiones anterior, la salida del TMP36 está conectada a una de las entradas analógicas del Arduino. El valor de esta entrada analógica se puede leer con la función analogRead() como verás en los ejemplos de código a continuación. Sin embargo, la función analogRead(pin) no devuelve directamente el voltaje de salida del sensor.
Las placas Arduino contienen un convertidor analógico a digital (ADC) multicanal de 10 bits, que mapea voltajes de entrada entre 0 y el voltaje de operación (5 V o 3.3 V) en valores enteros entre 0 y 1023. En un Arduino Uno, por ejemplo, esto da una resolución entre lecturas de 5 voltios / 1024 unidades, o 0.0049 voltios (4.9 mV) por unidad.
Así que si usas analogRead() para leer el voltaje en una de las entradas analógicas del Arduino, obtendrás un valor entre 0 y 1023.
Para convertir este valor de nuevo en el voltaje de salida del sensor, puedes usar:
V OUT = lectura del ADC * (5000 / 1024)
Y si usas un Arduino de 3.3 V:
V OUT = lectura del ADC * (3300 / 1024)
Usaremos estas fórmulas en los ejemplos de código a continuación.
Ejemplo de código para sensor de temperatura analógico TMP36 con Arduino
Con el siguiente código de ejemplo, puedes leer la temperatura de un sensor TMP36 y mostrarla en el Monitor Serial.
/* TMP36 analog temperature sensor with Arduino example code.
https://www.makerguides.com */
// Define to which pin of the Arduino the output of the TMP36 is connected:
#define sensorPin A0
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
}
void loop() {
// Get a reading from the temperature sensor:
int reading = analogRead(sensorPin);
// Convert the reading into voltage:
float voltage = reading * (5000 / 1024.0);
// Convert the voltage into the temperature in Celsius:
float temperature = (voltage - 500) / 10;
// Print the temperature in the Serial Monitor:
Serial.print(temperature);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.println("C");
delay(1000); // wait a second between readings
}
Deberías ver la siguiente salida en el Monitor Serial (Ctrl + Shift + M).
Asegúrate de que la velocidad en baudios del Monitor Serial también esté configurada a 9600.
Cómo funciona el código
Primero, definí a qué pin del Arduino está conectado el pin V OUT del sensor. En este caso, usamos el pin analógico A0. La instrucción #define se usa para dar un nombre a un valor constante. El compilador reemplazará todas las referencias a esta constante con el valor definido cuando se compile el programa. Así que donde menciones sensorPin, el compilador lo reemplazará por A0 al compilar el programa.
// Define to which pin of the Arduino the output of the TMP36 is connected: #define sensorPin A0
En la sección setup del código, iniciamos la comunicación serial a una velocidad de 9600 baudios.
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
}
En la sección loop del código, comenzamos tomando una lectura del sensor con la función analogRead(pin).
// Get a reading from the temperature sensor: int reading = analogRead(sensorPin);
Luego, usamos las fórmulas que mencioné antes en el artículo para convertir la lectura en voltaje y luego en temperatura.
// Convert the reading into voltage: float voltage = reading * (5000 / 1024.0); // Convert the voltage into the temperature in degree Celsius: float temperature = (voltage - 500) / 10;
Si usas un Arduino de 3.3 V, como el Arduino Due o Arduino Nano 33 BLE, necesitas conectar el pin +V S a 3.3 V y reemplazar la línea destacada con:
// Convert the reading into voltage: float voltage = reading * (3300 / 1024.0);
Por último, los resultados se imprimen en el Monitor Serial:
// Print the temperature in the Serial Monitor:
Serial.print(temperature);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.println("C");
Mostrar las lecturas de temperatura del TMP36 en un LCD I2C
Si quieres hacer un termómetro independiente que no necesite un ordenador, puede ser útil saber cómo mostrar las lecturas de temperatura en una pantalla LCD.
Con el código de ejemplo a continuación, puedes mostrar las lecturas de temperatura en un LCD I2C de 16×2 caracteres. Conectar el LCD I2C es bastante fácil, como puedes ver en el diagrama de conexiones a continuación.
Consulta el How to control a character I2C LCD with Arduino y el How to use a 16×2 character LCD with Arduino Tutorial para más detalles sobre pantallas LCD I2C.
Las conexiones también se muestran en la tabla a continuación:
Conexiones del LCD I2C
| LCD de caracteres I2C | Arduino |
|---|---|
| GND | GND |
| VCC | 5 V |
| SDA | A4 |
| SCL | A5 |
Ten en cuenta que el sensor de temperatura TMP36 está conectado de la misma manera que antes.
Instalación de las librerías necesarias para Arduino
Para usar un LCD I2C, necesitas instalar la librería LiquidCrystal_I2C para Arduino.
Para instalar esta librería, ve a Tools > Manage Libraries (Ctrl + Shift + I en Windows) en el IDE de Arduino. Se abrirá el Library Manager y actualizará la lista de librerías instaladas.
Ahora busca ‘liquidcrystal_i2c’ y busca la librería de Frank de Brabander. Selecciona la última versión y luego haz clic en Install.
Ejemplo de código TMP36 con LCD I2C
/* TMP36 analog temperature sensor with I2C LCD and Arduino example code.
https://www.makerguides.com */
// Include the required Arduino libraries:
#include "LiquidCrystal_I2C.h"
// Create a new instance of the LiquidCrystal_I2C class:
LiquidCrystal_I2C lcd(0x27, 16, 2);
// Degree symbol:
byte Degree[] = {
B00111,
B00101,
B00111,
B00000,
B00000,
B00000,
B00000,
B00000
};
// Define to which pin of the Arduino the TMP36 is connected:
#define sensorPin A0
void setup() {
// Start the LCD and turn on the backlight:
lcd.init();
lcd.backlight();
// Create a custom character:
lcd.createChar(0, Degree);
}
void loop() {
// Get a reading from the temperature sensor:
int reading = analogRead(sensorPin);
// Convert the reading into voltage:
float voltage = reading * (5000 / 1024.0);
// Convert the voltage into the temperature in degree Celsius:
float temperature = (voltage - 500) / 10;
// Print the temperature on the LCD;
lcd.setCursor(0, 0);
lcd.print("Temperature:");
lcd.setCursor(0, 1);
lcd.print(temperature);
lcd.write(0); // print the custom character
lcd.print("C");
delay(1000); // wait a second between readings
}
Deberías ver la siguiente salida en el LCD:
Conclusión
En este tutorial, te he mostrado cómo usar un sensor de temperatura analógico TMP36 con Arduino. Si quieres aprender más sobre otros sensores de temperatura, consulta los artículos a continuación.
- The complete guide for DS18B20 digital temperature sensors with Arduino
- How to use DHT11 and DHT22 Sensors with Arduino
- LM35 analog temperature sensor with Arduino tutorial
- How to control a character I2C LCD with Arduino
- How to use a 16×2 character LCD with Arduino
Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios.
