Componentes · 12 min de lectura

MAX6675 con Arduino: termopar tipo K para medir hasta 1000 °C

MAX6675 con Arduino: conexión SPI, librería y termopar tipo K para medir de 0 a 1023 °C, con LCD, estufa, horno, soldador y código para ESP32 y Pico.

El MAX6675 es un chip conversor que transforma la señal de milivoltios de un termopar tipo K directamente en un valor digital de temperatura; con MAX6675 y Arduino puedes medir de 0 a 1023,75 °C con una resolución de 0,25 °C. Donde sensores como el DHT11 o el DS18B20 aguantan como mucho 50–125 °C, por ejemplo en el tubo de una estufa, el horno de la cocina, un horno de pizza, la punta de una estación de soldadura o un tubo de escape, el termopar hace el trabajo. El módulo se conecta por SPI con solo tres cables de señal (SCK, CS, SO) y con su librería se lee en una sola línea.

En este artículo verás cómo funciona el termopar, qué contienen los 16 bits que envía el MAX6675 y las conexiones con Arduino Uno, ESP32 y Raspberry Pi Pico paso a paso. Después escribirás una alarma de temperatura con LCD para el tubo de una estufa y un termostato sencillo con relé para horno y estación de soldadura, y al final resolveremos los problemas más comunes, como "¿por qué leo NAN?" o "¿por qué baja el valor cuando calienta?".

¿Qué es el MAX6675 y un termopar, y cómo funcionan?

Un termopar está formado por dos hilos de metales distintos soldados por un extremo. Cuando hay una diferencia de temperatura entre ese punto de soldadura (extremo caliente) y los otros extremos de los hilos (extremo frío), aparece una tensión muy pequeña en los hilos; esto se llama efecto Seebeck. En un termopar tipo K el hilo positivo es cromel (níquel-cromo) y el negativo alumel (níquel-aluminio), y la tensión generada es de unos 41 µV/°C. Es decir, una diferencia de 100 °C da una señal de solo unos 4 mV, que no se puede medir directamente con el ADC de 10 bits del Arduino Uno (un paso son unos 4,9 mV). Además, el termopar no mide la temperatura absoluta sino la diferencia entre ambos extremos, así que también hay que conocer la temperatura del extremo frío, es decir, la del ambiente donde está el módulo. El MAX6675 hace justo estas dos cosas: amplifica la señal de microvoltios y la convierte a digital con un ADC de 12 bits, y con su sensor de temperatura interno realiza automáticamente la compensación de la unión fría. A ti solo te queda leer 16 bits por SPI. Según la hoja de datos, el error del propio chip es de unos pocos LSB, es decir, del orden de ±1,5–2 °C, al que se suma la tolerancia del termopar (±2,5 °C o el 0,75 % del valor medido para un tipo K estándar).

CaracterísticaValor
Chip conversorMAX6675
Termopar compatibleSolo tipo K
Rango de medida0 °C – 1023,75 °C
Resolución12 bits, 0,25 °C
Compensación de unión fríaInterna, temperatura ambiente −20 … +85 °C
Tensión de alimentación3,0 – 5,5 V
Consumo de corrienteTípico 0,7 mA, máximo 1,5 mA
Tiempo de conversiónTípico 0,17 s, máximo 0,22 s
InterfazCompatible con SPI, solo lectura (SCK, CS, SO), máx. 4,3 MHz
Detección de erroresBit de termopar abierto (D2)

¿MAX6675 u otro sensor de temperatura?

SensorRango de medidaResoluciónInterfazMejor uso
MAX6675 + termopar tipo K0 … 1023,75 °C0,25 °CSPIEstufa, horno, soldadura, escape
MAX31855K + termopar tipo K−200 … +1350 °C0,25 °CSPITemperaturas negativas y muy altas
DS18B20−55 … +125 °C0,0625 °C1-WireAgua, acuario, exterior
Termistor NTC (10 kΩ)Aprox. −40 … +125 °CDepende del ADCAnalógicaMedición barata de ambiente y equipos
DHT110 … 50 °C1 °CDigital de un hiloTemperatura y humedad ambiente

La sonda que suele venir con el módulo es un termopar tipo K con tornillo M6 en la punta y cable trenzado de fibra de vidrio. El aislamiento de este cable suele aguantar hasta unos 400 °C; es decir, aunque el MAX6675 pueda medir 1000 °C, la sonda en sí no está preparada para eso. Para medidas entre 600 y 1000 °C (horno de cerámica, crisol de fundición, forja) debes usar una sonda con funda cerámica o metálica y aislamiento mineral. Al medir una superficie (tubo de estufa, base de una plancha), aprieta la punta de la sonda contra la superficie con una abrazadera metálica; una sonda suspendida en el aire marca decenas de grados menos que la superficie. Como el MAX6675 no puede mostrar temperaturas por debajo de 0 °C, si vas a medir un congelador o el exterior en invierno elige el DS18B20 o el MAX31855. Para ver todas las opciones una al lado de otra, consulta la comparativa de sensores de temperatura.

Conexión del MAX6675: pines SPI

El módulo MAX6675 tiene cinco pines en un lado (GND, VCC, SCK, CS, SO) y, en el otro, dos bornes de tornillo (+ y −) donde se conecta el termopar. Como el chip solo envía datos, no hay línea MOSI; por eso, en lugar del SPI por hardware, también puedes usar SPI por software con tres pines digitales cualesquiera. En la tabla siguiente usamos los pines SPI por hardware de cada placa; así puedes trabajar con el mismo cableado tanto con la librería como con código SPI en bruto. La lógica básica del SPI la explicamos en detalle en el artículo ¿Qué es SPI?.

Pin del MAX6675Arduino UnoESP32Raspberry Pi Pico
GNDGNDGNDGND
VCC5V3V33V3(OUT)
SCKD13GPIO 18GP18
CSD10GPIO 5GP17
SOD12GPIO 19GP16
Termopar + / −Bornes + y − del móduloBornes + y − del móduloBornes + y − del módulo
La polaridad del termopar es importante: si al calentarlo el valor leído baja en lugar de subir, los hilos + y − están al revés; cámbialos de sitio. Los colores estándar varían según el país (en la norma de EE. UU., amarillo es positivo y rojo negativo; en la norma IEC, verde es positivo y blanco negativo), así que no te fíes del color sino de la prueba. Si necesitas alargar el cable del termopar, no uses cable de cobre normal; cada unión cobre-aleación se comporta como un termopar nuevo y falsea la medida. Para alargarlo usa cable de extensión para termopar tipo K, o deja el módulo junto a la sonda y alarga los cables de señal (SCK, CS, SO).

Paso a paso: primera medición con Arduino

  1. Atornilla firmemente los dos hilos del termopar a los bornes + y − del módulo.
  2. Conecta los pines GND y VCC del módulo a los pines GND y 5V del Arduino Uno.
  3. Conecta SCK a D13, CS a D10 y SO a D12.
  4. En el IDE de Arduino abre el Gestor de bibliotecas, busca MAX6675 e instala la MAX6675 library de Adafruit. Si nunca has instalado una librería, te ayudará el artículo Cómo añadir librerías en Arduino.
  5. Sube el código siguiente, abre el Monitor Serie a 9600 baudios y comprueba que el valor sube al sujetar la sonda con la mano.
C++ (Arduino IDE)
1#include <max6675.h>
2
3const int thermoSCK = 13;  // SCK (saat) / SCK (clock)
4const int thermoCS  = 10;  // CS (yonga seçimi) / CS (chip select)
5const int thermoSO  = 12;  // SO (veri çıkışı) / SO (data out)
6
7MAX6675 thermocouple(thermoSCK, thermoCS, thermoSO);  // sıra: SCK, CS, SO / order: SCK, CS, SO
8
9void setup() {
10  Serial.begin(9600);
11  Serial.println(F("MAX6675 test"));
12  delay(500);  // ilk dönüşümü bekle / wait for the first conversion
13}
14
15void loop() {
16  float c = thermocouple.readCelsius();
17  if (isnan(c)) {
18    Serial.println(F("Termokupl bagli degil! / Thermocouple not connected!"));
19  } else {
20    Serial.print(F("Sicaklik / Temp: "));
21    Serial.print(c, 2);
22    Serial.println(F(" C"));
23  }
24  delay(500);  // en az 250 ms bekle / wait at least 250 ms
25}

El constructor de la librería pide los pines en el orden SCK, CS, SO; confundir este orden es el error de software más habitual. readCelsius() devuelve la temperatura en Celsius y readFahrenheit() en Fahrenheit. Si el termopar no está conectado o el hilo está roto, el chip lo detecta y la librería devuelve NAN (no es un número). Capturar este caso con isnan() y mostrar un mensaje claro es vital cuando más adelante controles un calentador con un relé. A temperatura ambiente, si sujetas la sonda entre los dedos, el valor debería subir hasta unos 30 °C en pocos segundos.

El MAX6675 completa una conversión en 0,22 segundos como máximo y poner el pin CS en LOW detiene la conversión en curso. Por eso, si lees más a menudo que cada 250 ms, el chip no tiene tiempo de hacer una nueva medida y verás siempre el mismo valor. Deja al menos 250 ms entre lecturas; si quieres una pantalla más estable, haz la media de las últimas 4–8 medidas.

¿Cómo se leen los 16 bits de datos del MAX6675?

Si quieres leer sin librería, el proceso es simple: pon CS en LOW, lee dos bytes con 16 pulsos de reloj y vuelve a poner CS en HIGH. La distribución de los 16 bits recibidos es la de la tabla siguiente. Para obtener la temperatura, desplaza el valor en bruto 3 bits a la derecha (descartas D2, D1 y D0) y multiplica el resultado por 0,25. Por ejemplo, si el valor en bruto es 3200 (0x0C80 en hexadecimal), 3200 >> 3 = 400 y 400 × 0,25 = 100,00 °C. Como el mayor número que se puede escribir con 12 bits es 4095, el límite superior es 4095 × 0,25 = 1023,75 °C. Si no te manejas con desplazamientos y máscaras de bits, el artículo Sistemas numéricos y operaciones con bits te lo pondrá más fácil.

BitSignificado
D15Bit de signo ficticio, siempre 0
D14 – D3Valor de temperatura de 12 bits (primero el más significativo), 1 paso = 0,25 °C
D2Termopar abierto: si es 1, la sonda no está conectada o el hilo está roto
D1ID del dispositivo, siempre 0
D0Tres estados, valor indefinido

Mostrar la temperatura del tubo de una estufa en un LCD

En las casas con estufa, que el tubo se sobrecaliente significa riesgo de incendio y desperdicio de combustible. Fija la sonda con una abrazadera metálica a la superficie del tubo, en un punto cercano a la salida de la estufa. En las estufas de leña, la superficie del tubo suele mantenerse entre 120 y 250 °C con una combustión eficiente; por encima de 300 °C indica que la estufa está demasiado cargada o que el tiro de la chimenea es excesivo. El código siguiente muestra en un LCD I2C 16x2 la temperatura actual y el valor máximo medido desde el encendido, y hace sonar un zumbador activo conectado a D8 cuando se superan los 250 °C. Para la conexión del LCD (SDA a A4, SCL a A5) y para encontrar la dirección, consulta el artículo Pantalla LCD I2C.

Pantalla LCD 16x2 con módulo I2C
LCD 16x2 con módulo I2C: ideal para mostrar la temperatura medida con el MAX6675 con solo dos cables de datos (SDA, SCL).
C++ (Arduino IDE)
1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3#include <max6675.h>
4
5MAX6675 thermocouple(13, 10, 12);    // SCK, CS, SO
6LiquidCrystal_I2C lcd(0x27, 16, 2);  // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
7
8const int BUZZER_PIN = 8;            // aktif buzzer / active buzzer
9const float ALARM_C = 250.0;         // alarm eşiği / alarm threshold
10const float HYST_C  = 10.0;          // histerezis / hysteresis
11
12float maxC = 0;
13bool alarmOn = false;
14
15void setup() {
16  pinMode(BUZZER_PIN, OUTPUT);
17  lcd.init();
18  lcd.backlight();
19  lcd.print(F("Soba borusu"));
20  delay(1000);
21}
22
23void loop() {
24  float c = thermocouple.readCelsius();
25  lcd.clear();
26
27  if (isnan(c)) {
28    lcd.print(F("Prob bagli degil"));
29    alarmOn = false;
30  } else {
31    if (c > maxC) maxC = c;                                // en yüksek değer / peak value
32    if (!alarmOn && c >= ALARM_C) alarmOn = true;          // eşik aşıldı / threshold exceeded
33    if (alarmOn && c <= ALARM_C - HYST_C) alarmOn = false; // yeterince soğudu / cooled down enough
34
35    lcd.setCursor(0, 0);
36    lcd.print(F("Boru: "));
37    lcd.print(c, 1);
38    lcd.print((char)223);                                  // derece işareti / degree sign
39    lcd.print('C');
40
41    lcd.setCursor(0, 1);
42    if (alarmOn) {
43      lcd.print(F("COK SICAK!"));
44    } else {
45      lcd.print(F("Max: "));
46      lcd.print(maxC, 0);
47      lcd.print((char)223);
48      lcd.print('C');
49    }
50  }
51  digitalWrite(BUZZER_PIN, alarmOn ? HIGH : LOW);
52  delay(500);
53}

En el código usamos histéresis para la alarma: se activa a 250 °C, pero no se desactiva hasta que la temperatura baja de 240 °C. Así se evita que el zumbador se encienda y apague continuamente cuando el valor oscila en pasos de 0,25 °C alrededor del umbral. (char)223 es el símbolo de grado en la tabla de caracteres de los LCD basados en HD44780. El código supone un zumbador activo, que suena por sí solo; si usas uno pasivo, utiliza tone(BUZZER_PIN, 2000) y noTone(BUZZER_PIN) en lugar de digitalWrite. Si no se ve nada en la pantalla, cambia la dirección del LCD a 0x3F y prueba de nuevo.

Horno y estación de soldadura: control de temperatura con relé

Con la temperatura medida también puedes encender y apagar un calentador. El método más simple es el control todo/nada con histéresis: el calentador se enciende cuando la temperatura baja 3 °C por debajo del objetivo y se apaga cuando sube 3 °C por encima. Para un horno de cocina el objetivo suele estar entre 50 y 250 °C; en una estación de soldadura la temperatura de la punta se mantiene en torno a 330–370 °C para soldadura sin plomo y 300–340 °C para soldadura con plomo. Para medir la punta del soldador, usa un termopar fino con punta en forma de perla y asegura el contacto con una pequeña gota de estaño; una sonda gruesa de tornillo absorbe el calor de la punta y marca menos. En sistemas con mucha inercia térmica (como un horno), la temperatura sigue subiendo un rato aunque el relé se haya cortado; para un resultado más estable consulta el artículo Control PID. El código siguiente incluye además una capa de seguridad: si la sonda se rompe (NAN) o la temperatura supera los 300 °C, el calentador se apaga de inmediato. Para una estación de soldadura te basta con poner TARGET_C en 350 y MAX_SAFE en 420.

C++ (Arduino IDE)
1#include <max6675.h>
2
3MAX6675 thermocouple(13, 10, 12);   // SCK, CS, SO
4
5const int RELAY_PIN  = 7;
6const float TARGET_C = 180.0;   // hedef sıcaklık / target temperature
7const float BAND_C   = 3.0;     // ± bant / ± band
8const float MAX_SAFE = 300.0;   // güvenlik sınırı / safety limit
9
10bool heaterOn = false;
11
12void setup() {
13  Serial.begin(9600);
14  pinMode(RELAY_PIN, OUTPUT);
15  digitalWrite(RELAY_PIN, LOW);   // başlangıçta kapalı / off at start
16  delay(500);
17}
18
19void loop() {
20  float c = thermocouple.readCelsius();
21
22  if (isnan(c) || c > MAX_SAFE) {
23    heaterOn = false;             // prob koptu ya da aşırı sıcak / probe lost or overheated
24  } else if (c < TARGET_C - BAND_C) {
25    heaterOn = true;              // soğudu: ısıt / too cold: heat
26  } else if (c > TARGET_C + BAND_C) {
27    heaterOn = false;             // ısındı: kapat / too hot: stop
28  }
29
30  digitalWrite(RELAY_PIN, heaterOn ? HIGH : LOW);
31
32  Serial.print(c);
33  Serial.print(F(" C, isitici / heater: "));
34  Serial.println(heaterOn ? F("ON") : F("OFF"));
35  delay(500);
36}
Manejar dispositivos de 220 V como un horno, un calentador o un soldador conlleva un riesgo mortal. Asegúrate de que la corriente de contacto del relé es suficiente para el aparato (una resistencia de 1500 W consume unos 6,8 A a 220 V), coloca la parte de red en una caja aislada y, si no estás seguro, consulta a un profesional. Si vas a conmutar con frecuencia, un relé de estado sólido (SSR) dura mucho más que uno mecánico. Comprueba en el artículo Módulo de relé si tu módulo se activa con LOW o con HIGH; en algunos módulos tendrás que invertir la lógica HIGH y LOW del código.

Uso del MAX6675 con ESP32

Como el MAX6675 funciona entre 3,0 y 5,5 V, se puede conectar directamente al ESP32 alimentándolo desde el pin 3V3; así la línea SO también queda a 3,3 V y no hace falta un convertidor de nivel. La librería de Adafruit funciona igual en el ESP32, pero esta vez damos un ejemplo que lee con SPI por hardware y sin librería, para que veas también en el código cómo se decodifican los 16 bits. El código compila sin cambios en las versiones 2.x y 3.x del core Arduino para ESP32. El pin MOSI (GPIO 23) se define para el controlador SPI pero no se conecta al módulo. Si quieres enviar la medida al móvil por Wi-Fi, puedes combinar esta función con la estructura del artículo Servidor web y WebSocket con ESP32.

C++ (Arduino IDE)
1#include <SPI.h>
2
3const int PIN_SCK  = 18;  // MAX6675 SCK
4const int PIN_SO   = 19;  // MAX6675 SO (MISO)
5const int PIN_MOSI = 23;  // tanımlı ama bağlanmaz / defined but not connected
6const int PIN_CS   = 5;   // MAX6675 CS
7
8SPISettings maxSettings(1000000, MSBFIRST, SPI_MODE0);  // 1 MHz (sınır 4,3 MHz) / 1 MHz (limit 4.3 MHz)
9
10float readMAX6675() {
11  SPI.beginTransaction(maxSettings);
12  digitalWrite(PIN_CS, LOW);
13  delayMicroseconds(1);
14  uint16_t raw = SPI.transfer16(0x0000);  // 16 bit oku / read 16 bits
15  digitalWrite(PIN_CS, HIGH);
16  SPI.endTransaction();
17
18  if (raw & 0x0004) {          // D2 = 1: termokupl açık / thermocouple open
19    return NAN;
20  }
21  return (raw >> 3) * 0.25f;   // 12 bit x 0,25 °C
22}
23
24void setup() {
25  Serial.begin(115200);
26  SPI.begin(PIN_SCK, PIN_SO, PIN_MOSI, PIN_CS);  // SCK, MISO, MOSI, SS
27  pinMode(PIN_CS, OUTPUT);
28  digitalWrite(PIN_CS, HIGH);                    // CS elle sürülür / CS driven manually
29  delay(500);
30}
31
32void loop() {
33  float c = readMAX6675();
34  if (isnan(c)) {
35    Serial.println("Termokupl yok / No thermocouple");
36  } else {
37    Serial.printf("Sicaklik / Temp: %.2f C\n", c);
38  }
39  delay(500);  // en az 250 ms / at least 250 ms
40}

Raspberry Pi Pico con MAX6675 (MicroPython)

Para el Pico no necesitas ninguna librería adicional; basta con la clase machine.SPI integrada en MicroPython. Usamos los pines GP16 (MISO), GP17 (CS) y GP18 (SCK) del bus SPI0; alimenta el módulo desde el pin 3V3(OUT). spi.read(2) lee dos bytes: el primero es la parte más significativa de los datos y el segundo la menos significativa. Después, como en Arduino, desplazas 3 bits a la derecha y multiplicas por 0,25. Si eres nuevo en MicroPython, puedes empezar con el artículo Fundamentos de MicroPython.

MicroPython
1from machine import Pin, SPI
2import time
3
4spi = SPI(0, baudrate=1000000, polarity=0, phase=0,
5          sck=Pin(18), mosi=Pin(19), miso=Pin(16))  # GP19 bağlanmaz / GP19 is not connected
6cs = Pin(17, Pin.OUT, value=1)
7
8def read_max6675():
9    cs.value(0)
10    data = spi.read(2)              # 16 bit oku / read 16 bits
11    cs.value(1)
12    raw = (data[0] << 8) | data[1]
13    if raw & 0x04:                  # D2 = 1: termokupl açık / thermocouple open
14        return None
15    return (raw >> 3) * 0.25        # 12 bit x 0,25 C
16
17time.sleep_ms(500)                  # ilk dönüşüm / first conversion
18while True:
19    t = read_max6675()
20    if t is None:
21        print("Termokupl bagli degil / Thermocouple not connected")
22    else:
23        print("Sicaklik / Temp: {:.2f} C".format(t))
24    time.sleep_ms(500)              # en az 250 ms / at least 250 ms

Ideas de proyectos con el MAX6675

  • Alarma para el tubo de la estufa: lleva el ejemplo del LCD a un ESP32 y envía un mensaje de Telegram a tu móvil cuando el tubo se sobrecaliente.
  • Termómetro de horno: mide la temperatura interior real del horno de la cocina; no sería raro que difiriera entre 10 y 20 °C del valor que indica el mando del termostato.
  • Indicador de horno de piedra: mide con una sonda de funda metálica la temperatura de un horno de leña que llega a 400–450 °C y muéstrala en una matriz LED MAX7219 con un tamaño legible a distancia.
  • Tu propia estación de soldadura: controla la resistencia de un soldador con un SSR y PID, y ajusta la temperatura objetivo con un encoder rotatorio.
  • Horno de reflujo: convierte un pequeño horno tostador en un horno que sigue un perfil de temperatura para soldar SMD.
  • Registrador de temperatura: guarda en CSV en un módulo de tarjeta SD el proceso de una barbacoa, un tostado de café o un tratamiento térmico, y después dibuja su gráfica.
  • Monitorización de la temperatura del escape: vigila la temperatura del escape de un generador o una moto y da un aviso sonoro en caso de sobrecalentamiento.

Errores comunes y cómo solucionarlos

SíntomaCausa probableSolución
Siempre NAN o mensaje de "no conectado"El termopar no está puesto, el tornillo del borne está flojo o el hilo está rotoAtornilla bien los hilos; comprueba con un multímetro que entre los dos extremos de la sonda hay una resistencia baja (de unos pocos a unas decenas de ohmios)
Siempre 0,00 °CEl pin SO no está conectado o el orden de pines del constructor es incorrectoRevisa el cableado y el orden MAX6675(SCK, CS, SO)
El valor baja al calentarPolaridad del termopar invertidaIntercambia los hilos + y −
El valor no cambia nuncaLeer más a menudo que cada 250 ms interrumpe continuamente la conversiónDeja al menos 250 ms entre lecturas
Los valores saltan, hay ruidoRuido de relé o motor, cables largos, fluctuaciones de la alimentaciónAñade un condensador de 100 nF entre VCC y GND, haz la media de varias medidas y mantén cortos los cables de señal
A temperatura ambiente marca unos grados de másEl módulo está cerca de una superficie caliente o de un regulador; la unión fría ve una temperatura erróneaMueve el módulo lejos de la fuente de calor, a un lugar ventilado

El MAX6675 es el conversor de termopar más fácil de aprender, y hace accesible la medición de altas temperaturas con unos pocos cables y unas líneas de código. La calidad de la medida la determina casi siempre no el chip, sino la elección y el montaje de la sonda: apoya bien la sonda en la superficie, conecta la polaridad correctamente y no alargues el cable con cobre. Antes de pasar al control de calentadores, échale un vistazo también a las medidas de seguridad del artículo Termostato con Arduino. En la app de BlueGrays encontrarás proyectos como medición de temperatura con LCD, alarma con zumbador y registrador de temperatura con ESP32, con esquemas de circuito y código paso a paso, y podrás añadir fácilmente el MAX6675 a ellos.

Preguntas frecuentes

¿Hasta cuántos grados mide el MAX6675?

El MAX6675 mide de 0 °C a 1023,75 °C con una resolución de 0,25 °C. Sin embargo, en la práctica el límite superior suele fijarlo la propia sonda: las sondas de tornillo con cable de fibra de vidrio que vienen con el módulo suelen aguantar hasta unos 400 °C. Para medidas cercanas a 1000 °C necesitas una sonda tipo K con funda cerámica o metálica y aislamiento mineral.

¿Puede el MAX6675 medir temperaturas negativas?

No, el MAX6675 no puede mostrar temperaturas por debajo de 0 °C; el bit de signo del formato de datos es siempre cero. Para temperaturas negativas puedes usar el conversor de termopar MAX31855 o MAX31856, que llegan hasta −200 °C, o el DS18B20, que mide hasta −55 °C.

¿Por qué el MAX6675 me da NAN?

La librería devuelve NAN cuando ve que el bit de "termopar abierto" (D2) del chip vale 1. Normalmente significa que el termopar no está conectado, que el tornillo del borne está flojo o que el hilo se ha roto. Conecta bien los hilos y comprueba con un multímetro que entre los dos extremos de la sonda hay una resistencia baja.

¿Cuál es la diferencia entre el MAX6675 y el MAX31855?

Ambos leen un termopar tipo K por SPI y dan una resolución de 0,25 °C. El MAX31855 mide de −200 a +1350 °C con datos de 14 bits, informa por separado de los fallos de circuito abierto, cortocircuito a GND y cortocircuito a VCC, y además envía la temperatura de la unión fría. El MAX6675 se limita a 0–1023,75 °C, pero es más barato y más común; es más que suficiente para medir estufas, hornos y soldadores.

¿Se puede alargar el cable del termopar?

Se puede, pero no con cable de cobre normal. Cada punto donde se unen el cobre y las aleaciones del termopar se comporta como un termopar nuevo y añade error a la medida. Usa cable de extensión para termopar tipo K, o deja el módulo junto a la sonda y alarga los cables de señal SCK, CS y SO; tampoco conviene que la línea SPI supere unos pocos metros.

¿Funciona el MAX6675 con ESP32 y a 3,3 V?

Sí. El MAX6675 funciona entre 3,0 y 5,5 V; si alimentas el módulo desde el pin 3V3 de un ESP32 o de una Raspberry Pi Pico, la salida SO también será de 3,3 V y no necesitas convertidor de nivel. No se recomienda alimentar el módulo a 5 V y conectarlo a una placa de 3,3 V, porque enviaría 5 V por la línea SO.

Ver todos los proyectos
Temperatura y humedad con DHT11
AR-55Intermedio

Temperatura y humedad con DHT11

¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

4.7(47)
83
Uso del zumbador
AR-13Principiante

Uso del zumbador

¿Alguna vez te has preguntado cómo suena un timbre o una alarma? El Arduino hace pitar un pequeño zumbador a intervalos cortos: pip, silencio, pip, silencio.

4.7(92)
170
Medición de temperatura con NTC y pantalla LCD 2x16
AR-44Principiante
Premium

Medición de temperatura con NTC y pantalla LCD 2x16

Mide la temperatura del ambiente con un sensor que parece una pequeña cuenta. Esta pieza, llamada NTC, deja pasar la electricidad con más facilidad cuanto más se calienta; el Arduino lee ese cambio…

4.5(33)
44
Uso de la pantalla LCD con I2C
AR-32Principiante
Premium

Uso de la pantalla LCD con I2C

Dale a tu Arduino su propia pantalla y haz que escriba su primer mensaje. La pantalla LCD de dos líneas se conecta con solo unos pocos cables; primero aparece un saludo en la línea de arriba, luego…

4.8(53)
70
Pantalla LCD I2C para ESP32 (16x2)
ES-17Intermedio
Premium

Pantalla LCD I2C para ESP32 (16x2)

En este proyecto conectamos una pantalla LCD de caracteres 16x2 al ESP32 por I2C para mostrar texto. Con I2C bastan 2 pines de datos (SDA y SCL), en lugar de los 6+ pines de una conexión paralela clásica. El código escribe un mensaje fijo en la primera línea y un contador que sube cada segundo en la segunda. Al arrancar, un escáner I2C muestra la dirección de la pantalla en el Serial Monitor (normalmente 0x27 o 0x3F).

4.9(23)
40
ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)

Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

4.8(38)
57
Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzado
Premium

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

4.7(7)
12
Uso del sensor de llama
AR-50Intermedio
Premium

Uso del sensor de llama

Un pequeño vigilante que detecta el fuego antes que tú, en la cocina o en el taller.

4.6(33)
44