Aprender

Un termómetro de Arduino con un TMP36 y una LCD

Intermedio

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: termómetro con TMP36en vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
El ejemplo del termómetro en un ATmega328P simulado. Arrastra el control deslizante del sensor para cambiar la temperatura.

El TMP36 es el sensor de temperatura inicial clásico: tres patas, sin biblioteca, sin protocolo, y un voltaje que simplemente es la temperatura. El circuito de arriba es un Arduino Uno leyendo uno en A0 y mostrando la temperatura, más la más baja y la más alta que ha visto, en una LCD de caracteres de 16x2. Está corriendo en tu navegador ahora mismo con el mismo sketch que se muestra más abajo.

Arrastra el control deslizante del sensor y la pantalla lo sigue. El ejemplo imprime Celsius, como los termómetros de laboratorio que usan la mayoría de las clases, y esta página muestra la línea que lo convierte a Fahrenheit para una lectura estilo clima en EE. UU.

Lo que necesitas

  • Un Arduino Uno
  • Un sensor de temperatura TMP36
  • Una LCD de caracteres de 16x2 (la común de seis cables, no la versión con módulo I2C)
  • Una protoboard y cables jumper

Cableado

Componente y pinVa aNota
Pata izquierda del TMP36 (VS), lado plano hacia ti5 VLa alimentación, 2.7 V o más
Pata central del TMP36 (VOUT)A0La temperatura, como voltaje
Pata derecha del TMP36 (GND)GND
RS y E de la LCDPines 12 y 11Selección de registro y habilitación
LCD D4, D5, D6, D7Pines 5, 4, 3, 2Four-bit mode: four data wires instead of eight
VSS, RW, V0 y K de la LCDGNDRW en bajo significa solo escritura; V0 en GND es contraste máximo
VDD y A de la LCD5 VAlimentación de lógica e iluminación trasera

Cómo el TMP36 convierte el calor en volts

Alimenta el sensor y su pata central se queda en 500 milivolts a 0 °C (32 °F), y sube 10 milivolts por cada grado Celsius por encima de eso. La temperatura ambiente, 25 °C o 77 °F, son 750 mV. Un congelador a -10 °C (14 °F) son 400 mV.

That 500 mV offset is the whole trick of the part. It lets a sensor on a single 5 volt supply read below freezing without needing a negative voltage. It is also the thing almost every first sketch gets wrong. Leave it out, treating the sensor like an LM35 where 0 volts means 0 degrees, and every reading comes out 50 °C (90 °F) too hot.

La matemática, con números enteros

analogRead da de 0 a 1023 contra la referencia de 5 volts, así que una cuenta son 5000 / 1024 milivolts, que es exactamente 625 / 128. Resta el desfase de 500 mV y, como el sensor se mueve 10 mV por grado, cada milivolt restante es una décima de grado Celsius. Toda la conversión es decimas = lectura x 625 / 128 - 500, hecha con enteros de 32 bits, así que es exacta y no necesita punto flotante.

El sketch también promedia dieciséis lecturas antes de convertir. Aquí una cuenta equivale a aproximadamente medio grado, y el último bit de cualquier conversor es ruido, así que una sola lectura oscila entre dos valores para siempre. Sumar dieciséis muestras y desplazar cuatro bits a la derecha da un promedio estable sin división.

Para Fahrenheit, multiplica el valor Celsius por 9, divide entre 5 y suma 32. En décimas de grado es f10 = decimas x 9 / 5 + 320, todavía con números enteros. Úsalo para la línea de la pantalla y conserva el valor Celsius para cualquier cosa que un grupo de ciencias vaya a graficar.

La lectura, del ejemplo del termómetro, más Fahrenheit
static int16_t readTenths() {
  uint16_t total = 0;
  for (uint8_t i = 0; i < 16; i++) {
    total = (uint16_t)(total + (uint16_t)analogRead(SENSOR));
  }
  uint16_t mean = (uint16_t)(total >> 4);
  int32_t millivolts = ((int32_t)mean * 625) / 128;
  return (int16_t)(millivolts - 500);   // tenths of a degree C
}

// Tenths of a degree F, if you want the US reading on the display
int16_t tenthsF = (int16_t)((int32_t)readTenths() * 9 / 5 + 320);

La pantalla, y el máximo y el mínimo

The LCD is driven in four-bit mode: RS, E and four data lines, six wires in all. RW goes to ground because the sketch never reads the display back, and V0 goes to ground for full contrast. On a real module V0 usually goes to the middle of a 10 k potentiometer so you can adjust the contrast; if your screen shows a row of solid blocks or nothing at all, that pot is the first thing to turn.

La segunda fila muestra las lecturas mínima y máxima desde el encendido. Dos variables y dos comparaciones convierten un termómetro en algo que vale la pena dejar en un alféizar toda la noche.

Una diferencia con el IDE de Arduino: este ejemplo usa el header de LCD propio de Mokxi, mokxi_lcd1602.h, en lugar de la biblioteca LiquidCrystal. El cableado es el mismo. En un Uno real, incluye LiquidCrystal.h, crea LiquidCrystal lcd(12, 11, 5, 4, 3, 2), llama lcd.begin(16, 2), e imprime el valor con lcd.print().

Pruébalo en el editor

Agrega la línea de Fahrenheit a loop() e imprime ambas escalas, una en cada fila. Arrastra el deslizador a 0 °C y verifica que la pantalla diga 32 °F.

Luego pon la propiedad de desfase del sensor en 0 en el panel de propiedades. Eso lo convierte en un LM35. Observa cómo la lectura salta 50 grados, y cambia el sketch para que coincida.

Por último, suelta un multímetro en el lienzo y mide la pata central. A 25 °C marca 0.750 V, y puedes comprobar a mano la aritmética del sketch contra el medidor.

Errores comunes

Olvidar el desfase de 500 mV, así que todo marca 50 °C (90 °F) demasiado caliente.

Conectar el sensor al revés. Con la cara plana hacia ti y las patas hacia abajo, el orden es alimentación, salida, tierra. Invertido en un banco de trabajo real, un TMP36 se calienta lo suficiente para quemar un dedo.

Hacer la multiplicación en int con 1023 x 625, que desborda 16 bits en un Uno y da resultados sin sentido. Usa un long de 32 bits para la multiplicación.

Esperar precisión de laboratorio. Un TMP36 real tiene unos ±1 °C (±2 °F) a temperatura ambiente y ±2 °C en todo su rango. El simulado devuelve exactamente la temperatura que fijaste, lo cual sirve para aprender el código, pero no es una calibración.

Abre este circuito en el editor. Arduino Uno: termómetro con TMP36, cableado tal como corre arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Abrir el circuito

Preguntas

¿Cómo convierto el voltaje del TMP36 a temperatura?

Grados Celsius = (milivolts - 500) / 10. Grados Fahrenheit = Celsius x 9 / 5 + 32. En un Uno, milivolts = valor de analogRead x 5000 / 1024.

¿Por qué mi TMP36 marca unos 50 grados de más?

Falta el desfase de 500 mV en la matemática. El sensor entrega 500 mV a 0 °C, así que resta 500 antes de dividir entre 10.

¿Puedo usar un TMP36 con una placa de 3.3 V?

Sí. Necesita 2.7 V o más. La salida sigue la misma recta, y la escala completa del conversor es entonces 3.3 V, así que usa 3300 en lugar de 5000 en la matemática.

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.