LM35 Arduino: sensor de temperatura, conexión, fórmula y código

El LM35 es un sensor de temperatura analógico muy barato, de tres patillas, que convierte la temperatura directamente en una tensión en grados Celsius. Para usar el LM35 con Arduino no necesitas librerías ni protocolos complicados: conectas la patilla central a un pin analógico, la lees con analogRead() y obtienes la temperatura con una fórmula de una sola línea. Su salida sube exactamente 10 mV por cada 1 °C, así que da 250 mV a 25 °C y 1 V a 100 °C.

En esta guía aprenderás cómo funciona el LM35, cuál es el orden de sus patillas y el error de conexión invertida que casi todo el mundo comete alguna vez, cómo calcular los °C a partir del valor de analogRead, cómo hacer tus lecturas más de cuatro veces más finas con la referencia interna de 1,1 V del Arduino Uno y cómo calmar los valores que bailan promediando. Después verás qué tener en cuenta con el ESP32 y la Raspberry Pi Pico de 3,3 V, cómo se miden temperaturas bajo cero y cuándo elegir el LM35 frente al DS18B20 o el DHT11.

¿Qué es el LM35 y cómo funciona?

Dentro del LM35 hay dos transistores que trabajan con densidades de corriente distintas. La diferencia entre sus tensiones base-emisor cambia de forma directamente proporcional a la temperatura absoluta; esta técnica se llama delta-VBE. Un amplificador interno amplía esa pequeña diferencia y la ajusta para que la salida sea 0 V a 0 °C. Por eso, a diferencia de sensores en Kelvin como el LM335, no tienes que restar una gran tensión constante a la salida: temperatura (°C) = tensión de salida (mV) / 10. El sensor se ajusta en la propia oblea durante la fabricación, así que no necesita calibración adicional y su curva de salida es casi recta; su no linealidad típica es de solo ±0,25 °C.

El LM35 no es una sola pieza, sino una familia. La letra del sufijo define el rango de medida y la precisión garantizada, y la Z final indica el encapsulado de plástico TO-92. Según la hoja de datos, en TO-92 de plástico existen el LM35C, el LM35CA y el LM35D; la mayoría de los componentes que se venden como "LM35" en tiendas de electrónica son en realidad LM35DZ. Así que tu sensor muy probablemente solo está garantizado entre 0 y 100 °C y puede equivocarse hasta ±1,5 °C a 25 °C, aunque su error típico ronda los ±0,6 °C. Lee la serigrafía del componente para saber cuál tienes.

Patillaje del LM35 y el error más común: conectarlo al revés

Con la cara plana del LM35 mirando hacia ti y las patillas hacia abajo, el orden de izquierda a derecha es: patilla 1 +Vs (alimentación), patilla 2 Vout (salida) y patilla 3 GND (tierra). Como el dibujo de la hoja de datos es una vista inferior, mucha gente lo invierte mentalmente y lo conecta al revés. En los módulos LM35 montados en una pequeña placa, los pines suelen estar marcados como VCC (o +), OUT (o S) y GND (o −); en ese caso, fíate de la serigrafía de la placa.

Conexión del LM35 con Arduino: Uno, ESP32 y Pico

De analogRead a °C: la fórmula del LM35

El conversor analógico-digital (ADC) del Arduino Uno es de 10 bits: divide el rango entre 0 V y la tensión de referencia en 1024 escalones y te devuelve un número de 0 a 1023. Como la referencia es de 5 V por defecto, cada escalón equivale a 5 / 1024 = 4,88 mV. Primero conviertes el valor bruto en tensión y después la tensión en temperatura: tensión = bruto × 5,0 / 1024 y temperatura = tensión × 100. Juntando ambas, temperatura ≈ bruto × 0,488. En algunos ejemplos verás 1023 en lugar de 1024; la diferencia es de una milésima y no importa frente al error propio del LM35, pero lo correcto es 1024. Si quieres entender el ADC con más detalle, consulta el artículo sobre conversión analógico-digital (ADC).

Fíjate en la tabla: a temperatura ambiente el ADC solo produce un número en torno a 50, y un único escalón mueve la temperatura unos 0,5 °C. Por eso tu lectura salta entre 24,9 y 25,4; el sensor no está estropeado, es simplemente la resolución de la referencia de 5 V. Enseguida lo solucionaremos con la referencia interna.

Primera medición paso a paso

1. Pincha el LM35 en la protoboard; con la cara plana hacia ti, conecta la patilla izquierda a 5V y la derecha a GND.
2. Conecta la patilla central (Vout) a A0 con un cable jumper. Si tienes uno, añade un condensador de 0,1 µF entre +Vs y GND.
3. Conecta el Arduino por USB y toca el sensor al cabo de unos segundos: si está a temperatura ambiente, todo va bien; si quema, está conectado al revés.
4. Sube el código de abajo y abre el Monitor Serie a 9600 baudios.
5. Sujeta el sensor entre los dedos; deberías ver cómo el valor sube despacio y vuelve a bajar al soltarlo.

1const int LM35_PIN = A0;   // LM35 orta bacak (Vout) / LM35 middle leg (Vout)
2
3void setup() {
4  Serial.begin(9600);
5}
6
7void loop() {
8  int raw = analogRead(LM35_PIN);          // 0–1023 ham değer / raw value 0–1023
9  float voltage = raw * 5.0 / 1024.0;      // 5 V referansla volta çevir / convert to volts (5 V reference)
10  float tempC = voltage * 100.0;           // 10 mV/°C: 0,25 V = 25 °C / 0.25 V = 25 °C
11
12  Serial.print(F("Ham / Raw: "));
13  Serial.print(raw);
14  Serial.print(F("  Gerilim / Voltage: "));
15  Serial.print(voltage, 3);
16  Serial.print(F(" V  Sicaklik / Temp: "));
17  Serial.print(tempC, 1);
18  Serial.println(F(" C"));
19  delay(1000);
20}

Cada segundo, el código lee el valor bruto en A0, lo convierte primero en tensión y luego en temperatura, y muestra los tres en el Monitor Serie. Imprimir también el valor bruto ayuda mucho a depurar: si siempre es 0, no llega tensión desde Vout; si está cerca de 1023, el pin analógico se ha conectado por error a 5 V; si salta al azar, A0 está al aire. Escribir los textos fijos dentro de la macro F() ahorra parte de los 2 KB de RAM del Uno. Encontrarás más trucos en el artículo sobre cómo usar el Monitor Serie de Arduino.

Más resolución con la referencia interna de 1,1 V

La referencia de 5 V tiene dos problemas. El primero es la resolución gruesa que acabas de ver. El segundo es más traicionero: los 5 V del USB suelen estar en algún punto entre 4,7 y 5,1 V, y como en el código pones 5,0, la diferencia pasa directamente a la temperatura. Por ejemplo, si tu placa funciona en realidad a 4,8 V, verás 25 °C como 26 °C, y cuando el puerto USB del ordenador cae bajo carga, parece que la temperatura cambia sola. La solución es usar la referencia interna de 1,1 V del ATmega328P del Arduino Uno y Nano. Tras analogReference(INTERNAL), cada escalón vale 1,1 / 1024 = 1,07 mV, es decir, unos 0,11 °C. A cambio solo puedes medir hasta 1,1 V, o sea 110 °C, más que suficiente para el rango de 0–100 °C del LM35DZ.

La referencia de 1,1 V no es exactamente 1,1 V en todos los chips; según la hoja de datos del ATmega328P puede estar entre 1,0 y 1,2 V. Sin calibración, eso supone un error de escala de hasta el 9 %. La solución es sencilla: sube el código de abajo, mide con un multímetro la tensión entre el pin AREF y GND y escribe el valor en la constante VREF (por ejemplo const float VREF = 1.083;). Basta con hacerlo una vez por placa y el resultado sigue siendo válido. Además, el código promedia 32 muestras en cada lectura:

1const int LM35_PIN = A0;
2const float VREF = 1.1;     // AREF'te ölçtüğün değeri yaz (ör. 1.083) / write the voltage you measured on AREF (e.g. 1.083)
3const int SAMPLES = 32;     // ortalama için ölçüm sayısı / number of samples to average
4
5void setup() {
6  Serial.begin(9600);
7  analogReference(INTERNAL);        // Uno/Nano: 1,1 V dahili referans / 1.1 V internal reference
8  for (int i = 0; i < 5; i++) {     // referans değişti, ilk okumaları at / discard the first readings after switching
9    analogRead(LM35_PIN);
10    delay(10);
11  }
12}
13
14float readTempC() {
15  long sum = 0;
16  for (int i = 0; i < SAMPLES; i++) {
17    sum += analogRead(LM35_PIN);
18    delay(2);
19  }
20  float raw = sum / (float)SAMPLES;       // ortalama ham değer / average raw value
21  return raw * VREF / 1024.0 * 100.0;     // her basamak ~0,107 °C / each step is ~0.107 °C
22}
23
24void loop() {
25  float t = readTempC();
26  Serial.print(F("Sicaklik / Temp: "));
27  Serial.print(t, 2);
28  Serial.println(F(" C"));
29  if (t > 108.0) {
30    Serial.println(F("Uyari: 1,1 V sinirina yakin / Warning: close to the 1.1 V limit"));
31  }
32  delay(1000);
33}

Promediar lecturas y reducir el ruido

Una sola lectura de analogRead puede oscilar uno o dos escalones por el ruido en los cables y el rizado de la alimentación. La solución más sencilla y eficaz es promediar varias lecturas: el ruido aleatorio disminuye con la raíz cuadrada del número de muestras, así que la media de 16 lecturas lo reduce a la cuarta parte y la de 64 a la octava. Como la temperatura cambia despacio, decenas de lecturas en pocos milisegundos no te hacen perder tiempo. Para una curva aún más suave, usa un filtro exponencial: filtrado = filtrado + 0,1 × (nuevo − filtrado). Este filtro solo tiene en cuenta el 10 % de cada lectura nueva y guarda una única variable en memoria. Comparamos otros métodos, como la media móvil y la mediana, en el artículo sobre cómo filtrar datos de sensores.

• Descarta la primera lectura al cambiar de canal: si lees varios sensores analógicos, el condensador de muestreo del ADC conserva un momento la tensión del canal anterior; lee el mismo pin dos veces y descarta el primer resultado.
• Lleva el GND del sensor directamente al pin GND del Arduino: si la corriente de un relé, un motor o una tira LED pasa por el mismo cable de tierra, aparecen desplazamientos de milivoltios, y en el LM35 cada 10 mV es un grado.
• Usa cables cortos y lejos de los cables de potencia: los cables largos sin apantallar actúan como antenas; si hace falta, usa cable trenzado o apantallado.
• Aleja el sensor de fuentes de calor: un LM35 pegado a un regulador de tensión, a un módulo ESP32 o a un relé mide la temperatura de la placa, no la de la habitación.
• Calibra el offset una vez: deja el LM35 junto a un termómetro fiable y resta la diferencia constante en el código.

LM35 con ESP32: alimentación de 3,3 V y linealidad del ADC

El ESP32 funciona a 3,3 V, pero la hoja de datos del LM35 exige al menos 4 V de alimentación. Un LM35 alimentado a 3,3 V puede parecer que funciona a temperatura ambiente, pero su precisión no está garantizada. Lo correcto es alimentar el sensor desde el pin 5V de la placa (VIN en algunas), es decir, con los 5 V del USB. Esto no daña al ESP32, porque incluso en el peor caso (150 °C) la salida del LM35 nunca supera 1,5 V. Conecta siempre la salida a un pin ADC1 (GPIO 32–39), ya que los pines ADC2 no se pueden usar con el Wi-Fi activo. Para ver el mapa de pines detallado de tu placa, usa la herramienta Pinout, y si estás empezando con el ESP32, lee Qué es el ESP32.

El segundo tema es la linealidad del ADC del ESP32. Es de 12 bits (0–4095), pero no es lineal en los extremos: apenas distingue tensiones por debajo de 100 mV y su desviación cambia de una placa a otra. Como el LM35 solo da 200–300 mV a temperatura ambiente, esto te afecta directamente. La solución tiene dos pasos: elige la atenuación según el rango de tensión del LM35 y, en lugar del valor bruto, usa analogReadMilliVolts(), que aplica los datos de calibración grabados en el chip durante la fabricación. Como esta función devuelve directamente milivoltios, solo tienes que dividir el resultado entre 10 para obtener la temperatura.

1const int LM35_PIN = 34;     // ADC1_CH6, Wi-Fi açıkken de çalışır / works while Wi-Fi is on
2const int SAMPLES = 64;      // ortalama için ölçüm sayısı / number of samples to average
3
4void setup() {
5  Serial.begin(115200);
6  analogReadResolution(12);                       // 0–4095
7  analogSetPinAttenuation(LM35_PIN, ADC_2_5db);   // ~100–1250 mV, yani 10–125 °C / i.e. 10–125 °C
8}
9
10void loop() {
11  uint32_t sum = 0;
12  for (int i = 0; i < SAMPLES; i++) {
13    sum += analogReadMilliVolts(LM35_PIN);        // kalibre edilmiş mV / calibrated millivolts
14    delay(1);
15  }
16  float mv = sum / (float)SAMPLES;
17  float tempC = mv / 10.0;                        // 10 mV = 1 °C
18  Serial.printf("Gerilim / Voltage: %.1f mV  Sicaklik / Temp: %.2f C\n", mv, tempC);
19  delay(1000);
20}

LM35 con Raspberry Pi Pico y MicroPython

El ADC de 12 bits de la Pico está en los pines GP26, GP27 y GP28; como referencia usa ADC_VREF, una versión filtrada de la línea de 3,3 V. En MicroPython, read_u16() escala el resultado a 0–65535, así que tensión = bruto × 3,3 / 65535. La resolución teórica es de 0,8 mV, unos 0,08 °C, pero en la práctica el ADC de la Pico es algo ruidoso y da pequeños saltos en ciertos valores, así que aquí también es obligatorio promediar. Alimenta el LM35 desde VBUS (pin 40), que lleva los 5 V del USB; si alimentas la Pico con pilas en lugar de USB, asegúrate de que la tensión en VSYS supere los 4 V y alimenta el sensor desde ahí. Si es la primera vez que usas una Pico, encontrarás cómo instalar MicroPython en Qué es la Raspberry Pi Pico.

1from machine import ADC, Pin
2import time
3
4# Pin(23, Pin.OUT, value=1)  # yalnız Pico (W değil): regülatör PWM modu, daha az gürültü / Pico (not W) only: SMPS PWM mode, less noise
5lm35 = ADC(26)               # GP26 = ADC0, fiziksel pin 31 / physical pin 31
6VREF = 3.3                   # ADC_VREF'i multimetreyle ölçüp yaz / measure ADC_VREF with a multimeter
7SAMPLES = 64                 # ortalama için ölçüm sayısı / number of samples to average
8
9
10def read_temp_c():
11    total = 0
12    for _ in range(SAMPLES):
13        total += lm35.read_u16()   # 0–65535, 12 bit sonuç 16 bite ölçeklenir / 12-bit result scaled to 16 bits
14    raw = total / SAMPLES
15    volts = raw * VREF / 65535
16    return volts * 100             # 10 mV/°C
17
18
19while True:
20    t = read_temp_c()
21    print("Sicaklik / Temp: {:.2f} C".format(t))
22    time.sleep(1)

El chip de la Pico también tiene un sensor de temperatura (ADC(4)), pero mide la temperatura del propio chip, no la del ambiente, y en funcionamiento suele marcar unos grados de más; para la temperatura ambiente necesitas un sensor externo como el LM35. Para obtener lecturas más limpias en una Pico estándar, puedes poner GP23 en HIGH y pasar el regulador de la placa a modo PWM; así se reduce el rizado en ADC_VREF, aunque en reposo consume algo más. En la Pico W ese pin está reservado para el chip inalámbrico, por eso esa línea queda comentada en el código.

Medir temperaturas bajo cero con el LM35

En el montaje básico, el LM35 solo mide de 2 °C a 150 °C, porque su etapa de salida puede entregar corriente pero apenas puede absorberla, así que la salida no puede bajar de tierra. Para temperaturas negativas, la hoja de datos muestra dos caminos. El primero es conectar la salida a una alimentación negativa mediante una resistencia (R = Vs / 50 µA; 100 kΩ para −5 V), algo poco habitual en proyectos con Arduino porque no hay alimentación negativa. El segundo es el método con alimentación simple: elevas la patilla GND del LM35 aproximadamente 1 V sobre tierra con dos diodos en serie (por ejemplo 1N4148), pones una resistencia de 18 kΩ entre la salida y tierra, y lees la salida en A0 y la patilla GND del LM35 en A1. La temperatura es (tensión en A0 − tensión en A1) × 100. Para que entre las patillas del LM35 queden al menos 4 V, alimenta +Vs desde VIN (por ejemplo, con un adaptador de 9 V) en lugar de 5 V y usa la referencia de 5 V. Recuerda que el LM35DZ habitual no está garantizado por debajo de 0 °C; si necesitas medir bajo cero a menudo, el DS18B20 da muchos menos quebraderos de cabeza.

Comparativa: LM35, DS18B20 y DHT11

En resumen: si quieres un termómetro sencillo que responda rápido, no necesite librerías, use un solo pin analógico y funcione en un Arduino de 5 V, el LM35 es ideal; además es el sensor más didáctico para aprender lecturas analógicas y referencias del ADC. Si el cable es largo, necesitas temperaturas negativas, el sensor va dentro de un líquido o trabajas con placas de 3,3 V como el ESP32 y la Pico, el DS18B20 es mejor opción. Si además quieres medir humedad, usa el DHT11 o su hermano más preciso, el DHT22. Para una comparativa más amplia que incluye termistores NTC, el BME280 y otros, consulta Comparativa de sensores de temperatura para Arduino.

Ideas de proyectos con el LM35

El proyecto más popular con el LM35 es un termostato que enciende un ventilador cuando la temperatura supera un valor. Lo importante es usar histéresis: si el ventilador se enciende a 30 °C y se apaga a 28 °C, el relé no estará conmutando cada segundo cuando la temperatura ronde justo el umbral y sus contactos no se desgastarán. Puedes controlar el ventilador con un módulo de relé conectado a D7:

1const int LM35_PIN = A0;
2const int RELAY_PIN = 7;          // röle modülünün IN pini / relay module IN pin
3const float ON_TEMP = 30.0;       // bu değerde fan açılır / fan turns on here
4const float OFF_TEMP = 28.0;      // bu değerde fan kapanır / fan turns off here
5const float VREF = 1.1;           // ölçtüğün AREF değeri / your measured AREF value
6bool fanOn = false;
7
8float readTempC() {
9  long sum = 0;
10  for (int i = 0; i < 32; i++) {
11    sum += analogRead(LM35_PIN);
12  }
13  return (sum / 32.0) * VREF / 1024.0 * 100.0;
14}
15
16void setup() {
17  Serial.begin(9600);
18  pinMode(RELAY_PIN, OUTPUT);
19  digitalWrite(RELAY_PIN, LOW);
20  analogReference(INTERNAL);      // 1,1 V referans / 1.1 V reference
21  analogRead(LM35_PIN);           // ilk okumayı at / discard the first reading
22  delay(10);
23}
24
25void loop() {
26  float t = readTempC();
27  if (!fanOn && t >= ON_TEMP) fanOn = true;      // eşik aşıldı / threshold exceeded
28  if (fanOn && t <= OFF_TEMP) fanOn = false;     // yeterince soğudu / cooled down enough
29  digitalWrite(RELAY_PIN, fanOn ? HIGH : LOW);   // aktif-HIGH röle varsayıldı / assumes an active-HIGH relay
30  Serial.print(t, 1);
31  Serial.println(fanOn ? " C  fan ON" : " C  fan OFF");
32  delay(1000);
33}

• Termostato de ventilador ajustable: combina el código anterior con un ventilador DC y un relé, y sube o baja el umbral con dos pulsadores.
• Termómetro digital con LCD: muestra la temperatura en una pantalla LCD I2C o en una pantalla OLED junto con la mínima y la máxima del día.
• Alarma de sobrecalentamiento: haz sonar un zumbador y encender un LED cuando una fuente de alimentación, un cargador de baterías o el motor de una impresora 3D se calienten demasiado.
• Termómetro de habitación con Wi-Fi: muestra la temperatura medida por el ESP32 en una página web que abres desde el móvil.
• Control de invernadero e incubadora: monta un sistema que gestione un calefactor y un ventilador según la temperatura; tienes los detalles en el artículo del invernadero inteligente.
• Registrador de temperatura: guarda una lectura por minuto en una tarjeta SD y dibuja la curva diaria en Excel.

Errores frecuentes y cómo solucionarlos

El LM35 es una pieza de iniciación perfecta para aprender lecturas analógicas, referencias del ADC y filtrado de señales: empiezas con una sola fórmula y, con la referencia adecuada, el promedio y la calibración, consigues que tu medida sea tan fiable como un termómetro. Aplicarás la misma lógica a otros sensores analógicos, como el termistor NTC. En la app BlueGrays encontrarás proyectos como la medición de temperatura con NTC y LCD, temperatura y humedad con el DHT11, una estación de temperatura con ESP32 y LCD y un registrador de temperatura, todos con esquemas paso a paso y código listo para usar.