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ística | Valor |
|---|---|
| Chip conversor | MAX6675 |
| Termopar compatible | Solo tipo K |
| Rango de medida | 0 °C – 1023,75 °C |
| Resolución | 12 bits, 0,25 °C |
| Compensación de unión fría | Interna, temperatura ambiente −20 … +85 °C |
| Tensión de alimentación | 3,0 – 5,5 V |
| Consumo de corriente | Típico 0,7 mA, máximo 1,5 mA |
| Tiempo de conversión | Típico 0,17 s, máximo 0,22 s |
| Interfaz | Compatible con SPI, solo lectura (SCK, CS, SO), máx. 4,3 MHz |
| Detección de errores | Bit de termopar abierto (D2) |
¿MAX6675 u otro sensor de temperatura?
| Sensor | Rango de medida | Resolución | Interfaz | Mejor uso |
|---|---|---|---|---|
| MAX6675 + termopar tipo K | 0 … 1023,75 °C | 0,25 °C | SPI | Estufa, horno, soldadura, escape |
| MAX31855K + termopar tipo K | −200 … +1350 °C | 0,25 °C | SPI | Temperaturas negativas y muy altas |
| DS18B20 | −55 … +125 °C | 0,0625 °C | 1-Wire | Agua, acuario, exterior |
| Termistor NTC (10 kΩ) | Aprox. −40 … +125 °C | Depende del ADC | Analógica | Medición barata de ambiente y equipos |
| DHT11 | 0 … 50 °C | 1 °C | Digital de un hilo | Temperatura 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 MAX6675 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| GND | GND | GND | GND |
| VCC | 5V | 3V3 | 3V3(OUT) |
| SCK | D13 | GPIO 18 | GP18 |
| CS | D10 | GPIO 5 | GP17 |
| SO | D12 | GPIO 19 | GP16 |
| Termopar + / − | Bornes + y − del módulo | Bornes + y − del módulo | Bornes + y − del módulo |
Paso a paso: primera medición con Arduino
- Atornilla firmemente los dos hilos del termopar a los bornes + y − del módulo.
- Conecta los pines GND y VCC del módulo a los pines GND y 5V del Arduino Uno.
- Conecta SCK a D13, CS a D10 y SO a D12.
- 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.
- 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.
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.
¿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.
| Bit | Significado |
|---|---|
| D15 | Bit de signo ficticio, siempre 0 |
| D14 – D3 | Valor de temperatura de 12 bits (primero el más significativo), 1 paso = 0,25 °C |
| D2 | Termopar abierto: si es 1, la sonda no está conectada o el hilo está roto |
| D1 | ID del dispositivo, siempre 0 |
| D0 | Tres 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.

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.
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}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.
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.
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 msIdeas 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íntoma | Causa probable | Solución |
|---|---|---|
| Siempre NAN o mensaje de "no conectado" | El termopar no está puesto, el tornillo del borne está flojo o el hilo está roto | Atornilla 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 °C | El pin SO no está conectado o el orden de pines del constructor es incorrecto | Revisa el cableado y el orden MAX6675(SCK, CS, SO) |
| El valor baja al calentar | Polaridad del termopar invertida | Intercambia los hilos + y − |
| El valor no cambia nunca | Leer más a menudo que cada 250 ms interrumpe continuamente la conversión | Deja al menos 250 ms entre lecturas |
| Los valores saltan, hay ruido | Ruido de relé o motor, cables largos, fluctuaciones de la alimentación | Añ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ás | El módulo está cerca de una superficie caliente o de un regulador; la unión fría ve una temperatura errónea | Mueve 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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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…

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.

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…

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…

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).

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.

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.

Uso del sensor de llama
Un pequeño vigilante que detecta el fuego antes que tú, en la cocina o en el taller.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

