Sensor MAX30102 Arduino: pulso y SpO2, conexión y código
Conecta el MAX30102 a Arduino (I2C, 0x57) y mide pulso y SpO2 con la librería SparkFun: LED rojo e IR, colocación del dedo y códigos para Uno, ESP32 y Pico.
El MAX30102 es un pequeño sensor óptico que se usa en proyectos con Arduino para medir el pulso (frecuencia cardíaca) y la saturación de oxígeno en sangre (SpO2) desde la yema del dedo. Dentro de un solo chip hay un LED rojo y otro infrarrojo (IR), un fotodiodo que detecta la luz, un ADC de 18 bits y una memoria (FIFO) que acumula las medidas. Se comunica con Arduino con solo dos hilos de datos, es decir, por I2C; por eso se conecta en pocos minutos a Uno, ESP32 y Raspberry Pi Pico. Es exactamente el mismo principio de funcionamiento de los pulsioxímetros de dedo que venden en las farmacias.
En este artículo verás cómo mide el MAX30102 el pulso y el oxígeno con luz, los pines del módulo y la tabla de conexión para cada placa, cómo leer el pulso con la librería SparkFun en Arduino Uno, cómo calcular pulso y SpO2 a la vez en ESP32 y el código en MicroPython sin librería para la Pico. Al final aprenderás a vencer a los dos mayores enemigos de la medida: la mala colocación del dedo y el movimiento.
¿Qué es el MAX30102 y cómo funciona?
El sensor envía luz roja e infrarroja a la yema del dedo y el fotodiodo, situado justo al lado, mide la luz que vuelve reflejada por el tejido. Como los LED y el detector están en la misma cara, se llama medida por reflexión. En cada latido los capilares del dedo se llenan un poco más de sangre; como la sangre absorbe luz, la luz que llega al fotodiodo disminuye en ese instante. Así, la señal medida contiene una pequeña onda que sube y baja al ritmo del corazón. Este método se llama fotopletismografía (PPG). Si mides el tiempo entre dos latidos obtienes el pulso: si los latidos llegan cada 0,8 segundos, el pulso es 60 / 0,8 = 75 BPM (latidos por minuto).
La medida de oxígeno se basa en que los dos colores se comportan de forma distinta en la sangre. La hemoglobina con oxígeno absorbe más luz infrarroja y menos luz roja; la hemoglobina sin oxígeno absorbe más luz roja. Para cada color, el sensor calcula la relación entre la variación de la señal (AC) y su nivel constante (DC) y divide ambas relaciones: R = (AC_rojo / DC_rojo) / (AC_IR / DC_IR). Cuanto menor es R, mayor es la SpO2. El algoritmo de ejemplo de Maxim convierte R en porcentaje con la fórmula aproximada SpO2 = −45,060·R² + 30,354·R + 94,845; para R = 0,5 sale cerca del 98,8 % y para R = 1 cerca del 80 %. Como ves, un pequeño error de medida supone una desviación de varios puntos en la SpO2.
| Característica | Valor |
|---|---|
| Fabricante | Maxim Integrated (hoy Analog Devices) |
| LED | Rojo 660 nm, infrarrojo (IR) 880 nm |
| ADC | Resolución de hasta 18 bits, 50–3200 muestras/segundo |
| Memoria | FIFO de 32 muestras |
| Interfaz | I2C, dirección 0x57 (en notación de 8 bits: escritura 0xAE, lectura 0xAF), hasta 400 kHz |
| Alimentación del chip | Núcleo 1,8 V, LED 3,1–5 V |
| Alimentación del módulo | VIN 3,3–5 V (la placa lleva reguladores) |
| Corriente de los LED | Se ajusta por software entre 0 y 50 mA (pasos de 0,2 mA) |
| Corriente en modo apagado | Aprox. 0,7 µA |
| Función extra | Sensor de temperatura interno que mide la temperatura del chip |
Diferencias entre MAX30102, MAX30100 y los sensores de pulso analógicos
| Característica | MAX30102 | MAX30100 | Pulse Sensor / KY-039 |
|---|---|---|---|
| Qué mide | Pulso + SpO2 | Pulso + SpO2 | Solo pulso |
| Salida | I2C (digital) | I2C (digital) | Tensión analógica |
| Resolución del ADC | Hasta 18 bits | Hasta 16 bits | El ADC del microcontrolador |
| FIFO | 32 muestras | 16 muestras | No tiene |
| Fuente de luz | Rojo + IR | Rojo + IR | LED verde o LED IR |
| Complejidad del código | Fácil con librería | Fácil con librería | La más simple con analogRead |

Pines del MAX30102 y tabla de conexión
| Pin del MAX30102 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN | 5V (o 3.3V) | 3V3 | 3V3(OUT) (pin 36) |
| GND | GND | GND | GND |
| SCL | A5 | GPIO 22 | GP5 (pin 7) |
| SDA | A4 | GPIO 21 | GP4 (pin 6) |
| INT | Puede quedar sin conectar | Puede quedar sin conectar | Puede quedar sin conectar |
| IRD / RD | Déjalo libre | Déjalo libre | Déjalo libre |
La dirección I2C del sensor es fija: 0x57. Si dudas de los cables, puedes ejecutar un escáner I2C y comprobar que aparece esa dirección; explicamos con detalle cómo funciona el bus I2C en ¿Qué es I2C?. El pin INT es una salida de interrupción que pasa a LOW cuando hay datos nuevos; como los códigos de este artículo consultan el sensor continuamente, no necesitas este pin. Los pines IRD y RD son los terminales de control de los LED y en el uso normal quedan libres.
Instalación de la librería: SparkFun MAX3010x
- En el IDE de Arduino abre el Gestor de bibliotecas y escribe SparkFun MAX3010x.
- Instala la SparkFun MAX3010x Pulse and Proximity Sensor Library. Aunque en el nombre aparezca MAX30105, funciona igual con el MAX30102; el MAX30102 solo carece del LED verde.
- La librería incluye tres archivos: MAX30105.h, que controla el sensor; heartRate.h, que detecta los latidos; y spo2_algorithm.h, que contiene el algoritmo de SpO2 de Maxim.
- Si eres nuevo instalando librerías, échale un vistazo a Cómo añadir una librería a Arduino.
Medir el pulso (BPM) con Arduino Uno
1#include <Wire.h>
2#include "MAX30105.h" // MAX30102 ile de çalışır / also works with MAX30102
3#include "heartRate.h"
4
5MAX30105 sensor;
6
7const byte RATE_SIZE = 4; // son 4 atımın ortalaması / average of last 4 beats
8byte rates[RATE_SIZE];
9byte rateSpot = 0;
10unsigned long lastBeat = 0;
11float bpm = 0;
12int bpmAvg = 0;
13unsigned long lastPrint = 0;
14
15void setup() {
16 Serial.begin(115200);
17 if (!sensor.begin(Wire, I2C_SPEED_FAST)) { // 400 kHz I2C
18 Serial.println(F("MAX30102 bulunamadi / not found"));
19 while (1);
20 }
21 // parlaklık, ortalama, mod (2 = kırmızı + IR), örnek hızı, darbe genişliği, ADC aralığı
22 // brightness, averaging, mode (2 = red + IR), sample rate, pulse width, ADC range
23 sensor.setup(0x1F, 4, 2, 400, 411, 4096);
24 sensor.setPulseAmplitudeRed(0x0A); // kırmızı LED kısık, ölçüm IR ile / dim red LED, IR does the work
25}
26
27void loop() {
28 long ir = sensor.getIR();
29
30 if (checkForBeat(ir)) { // yeni bir atım yakalandı / a new beat detected
31 unsigned long now = millis();
32 unsigned long delta = now - lastBeat;
33 lastBeat = now;
34 bpm = 60.0 / (delta / 1000.0);
35 if (bpm > 20 && bpm < 255) { // mantıksız değerleri at / drop impossible values
36 rates[rateSpot++] = (byte)bpm;
37 rateSpot %= RATE_SIZE;
38 bpmAvg = 0;
39 for (byte i = 0; i < RATE_SIZE; i++) bpmAvg += rates[i];
40 bpmAvg /= RATE_SIZE;
41 }
42 }
43
44 if (millis() - lastPrint > 500) { // yarım saniyede bir yaz / print every 0.5 s
45 lastPrint = millis();
46 Serial.print(F("IR="));
47 Serial.print(ir);
48 if (ir < 50000) {
49 Serial.println(F(" Parmak yok / No finger"));
50 } else {
51 Serial.print(F(" BPM="));
52 Serial.print(bpm, 0);
53 Serial.print(F(" Ort/Avg="));
54 Serial.println(bpmAvg);
55 }
56 }
57}| Fragmento de código | ¿Qué hace? |
|---|---|
| sensor.begin(Wire, I2C_SPEED_FAST) | Inicia el sensor con I2C a 400 kHz; si no lo encuentra, devuelve false. |
| sensor.setup(0x1F, 4, 2, 400, 411, 4096) | Elige una corriente de LED de unos 6,2 mA, un promedio de 4 muestras, el modo rojo + IR, 400 muestras/s, un pulso de 411 µs y un rango de ADC de 4096 nA. |
| sensor.getIR() | Devuelve la última medida infrarroja; con un dedo puesto suele superar las 50.000. |
| checkForBeat(ir) | Devuelve true cuando detecta cada pico de latido en la señal. |
| 60.0 / (delta / 1000.0) | Convierte los milisegundos entre dos latidos en latidos por minuto. |
| Array rates[] | Suaviza los valores que saltan haciendo la media de las últimas 4 medidas. |
Leer pulso y SpO2 a la vez (ESP32 y Uno)
Para medir el oxígeno no basta con contar picos; hace falta un registro de unos segundos de las señales roja e IR. El código siguiente se configura para tomar 25 muestras por segundo (medida a 100 Hz, promedio de 4) y llena una ventana de 100 muestras, es decir, 4 segundos. Después, el algoritmo de Maxim calcula con esa ventana tanto el pulso como la SpO2. En las vueltas siguientes se descartan las 25 muestras más antiguas y se añaden 25 nuevas, así obtienes un resultado nuevo cada segundo. Como los 2 KB de RAM del Uno no dan para dos arrays de 32 bits, el código pasa automáticamente a arrays de 16 bits en el Uno; el ejemplo oficial de SparkFun sigue el mismo camino.
1#include <Wire.h>
2#include "MAX30105.h"
3#include "spo2_algorithm.h"
4
5MAX30105 sensor;
6
7#if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)
8uint16_t irBuffer[100]; // Uno'da RAM yetmediği için 16 bit / 16-bit on Uno to save RAM
9uint16_t redBuffer[100];
10#else
11uint32_t irBuffer[100]; // ESP32'de tam 32 bit / full 32-bit on ESP32
12uint32_t redBuffer[100];
13#endif
14
15const int32_t BUFFER_LENGTH = 100; // 25 örnek/s x 4 s / 25 samples/s x 4 s
16int32_t spo2;
17int8_t validSpo2;
18int32_t heartRate;
19int8_t validHeartRate;
20bool firstFill = true;
21
22void readSample(int i) {
23 while (!sensor.available()) sensor.check(); // yeni örnek bekle / wait for a new sample
24 redBuffer[i] = sensor.getRed();
25 irBuffer[i] = sensor.getIR();
26 sensor.nextSample();
27}
28
29void setup() {
30 Serial.begin(115200);
31#if defined(ESP32)
32 Wire.begin(21, 22); // SDA, SCL
33#endif
34 if (!sensor.begin(Wire, I2C_SPEED_FAST)) {
35 Serial.println(F("MAX30102 bulunamadi / not found"));
36 while (1);
37 }
38 // parlaklık 60 (~12 mA), 4 ortalama, kırmızı + IR, 100 Hz, 411 us, 4096 nA
39 // brightness 60 (~12 mA), average 4, red + IR, 100 Hz, 411 us, 4096 nA
40 sensor.setup(60, 4, 2, 100, 411, 4096);
41}
42
43void loop() {
44 if (firstFill) { // ilk 4 saniyeyi doldur / fill the first 4 seconds
45 for (int i = 0; i < BUFFER_LENGTH; i++) readSample(i);
46 firstFill = false;
47 } else { // 25 örnek kaydır, 25 yeni oku / shift 25, read 25 new
48 for (int i = 25; i < BUFFER_LENGTH; i++) {
49 redBuffer[i - 25] = redBuffer[i];
50 irBuffer[i - 25] = irBuffer[i];
51 }
52 for (int i = 75; i < BUFFER_LENGTH; i++) readSample(i);
53 }
54
55 maxim_heart_rate_and_oxygen_saturation(irBuffer, BUFFER_LENGTH, redBuffer,
56 &spo2, &validSpo2, &heartRate, &validHeartRate);
57
58 Serial.print(F("Nabiz / HR: "));
59 if (validHeartRate) Serial.print(heartRate); else Serial.print(F("--"));
60 Serial.print(F(" BPM SpO2: "));
61 if (validSpo2) Serial.print(spo2); else Serial.print(F("--"));
62 Serial.println(F(" %"));
63}| Parámetro de setup() | Valor en este código | Opciones |
|---|---|---|
| ledBrightness | 60 (unos 12 mA) | 0 = apagado … 255 = 50 mA |
| sampleAverage | 4 | 1, 2, 4, 8, 16, 32 |
| ledMode | 2 (rojo + IR) | 1 = solo rojo, 2 = rojo + IR, 3 = también verde (solo MAX30105) |
| sampleRate | 100 | 50, 100, 200, 400, 800, 1000, 1600, 3200 |
| pulseWidth | 411 µs (18 bits) | 69, 118, 215, 411 µs |
| adcRange | 4096 nA | 2048, 4096, 8192, 16384 |
MAX30102 con ESP32
El código de SpO2 anterior funciona en el ESP32 sin cambiar nada; los pines I2C por defecto son GPIO 21 (SDA) y GPIO 22 (SCL) y, como el código solo usa la librería Wire, compila igual en las versiones 2.x y 3.x del núcleo Arduino para ESP32. Alimenta siempre el módulo desde el pin 3V3; así las líneas I2C se mantienen a 3,3 V. La abundante RAM del ESP32 da sitio de sobra a los búferes de 32 bits, y su segundo núcleo y su Wi-Fi facilitan llevar las medidas al móvil o a internet. Por ejemplo, puedes mostrar los resultados en una pantalla OLED, enviarlos al móvil por Bluetooth BLE o medir a intervalos cortos y pasar a deep sleep entre medidas para alargar la vida de la batería. La OLED y el sensor pueden compartir la misma línea I2C; al tener direcciones distintas (0x3C y 0x57), no hay conflicto.
MAX30102 con Raspberry Pi Pico y MicroPython
No existe un controlador oficial listo para el MAX30102 en MicroPython, pero como los registros del sensor son sencillos puedes manejarlo tú mismo con unas pocas líneas. El código siguiente pone el sensor en modo SpO2, lee del FIFO las muestras roja e IR, detecta los latidos a partir de la señal IR y, con la ventana de 4 segundos, calcula la relación R y muestra un valor aproximado de SpO2. Si eres nuevo con la Pico y MicroPython, mira antes ¿Qué es la Raspberry Pi Pico? y Fundamentos de MicroPython.
1from machine import Pin, I2C
2import time
3
4ADDR = 0x57 # MAX30102 I2C adresi / I2C address
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
6
7def wr(reg, val):
8 i2c.writeto_mem(ADDR, reg, bytes([val]))
9
10def rd(reg, n=1):
11 return i2c.readfrom_mem(ADDR, reg, n)
12
13if rd(0xFF)[0] != 0x15: # PART_ID kontrolü / PART_ID check
14 raise RuntimeError("MAX30102 bulunamadi / not found")
15
16wr(0x09, 0x40) # yazılımla sıfırla / software reset
17time.sleep_ms(100)
18wr(0x08, 0x5F) # 4 örnek ortalama + FIFO rollover / 4-sample average + rollover
19wr(0x09, 0x03) # SpO2 modu: kırmızı + IR / SpO2 mode: red + IR
20wr(0x0A, 0x27) # 4096 nA, 100 Hz, 411 us (18 bit)
21wr(0x0C, 0x24) # kırmızı LED ~7,2 mA / red LED ~7.2 mA
22wr(0x0D, 0x24) # IR LED ~7,2 mA / IR LED ~7.2 mA
23for reg in (0x04, 0x05, 0x06): # FIFO işaretçilerini sıfırla / reset FIFO pointers
24 wr(reg, 0)
25
26def read_fifo():
27 n = (rd(0x04)[0] - rd(0x06)[0]) & 0x1F # bekleyen örnek / pending samples
28 out = []
29 if n:
30 d = rd(0x07, 6 * n) # her örnek 6 bayt / 6 bytes per sample
31 for i in range(n):
32 k = 6 * i
33 red = ((d[k] << 16) | (d[k + 1] << 8) | d[k + 2]) & 0x3FFFF
34 ir = ((d[k + 3] << 16) | (d[k + 4] << 8) | d[k + 5]) & 0x3FFFF
35 out.append((red, ir))
36 return out
37
38FS = 25 # 100 Hz / 4 ortalama = 25 örnek/s / effective sample rate
39WIN = 100 # 4 saniyelik pencere / 4 second window
40reds, irs, beats = [], [], []
41dc = 0.0
42above = False
43count = 0
44last_beat = 0
45
46while True:
47 for red, ir in read_fifo():
48 count += 1
49 if ir < 50000: # parmak yok / no finger
50 reds, irs, beats = [], [], []
51 dc = 0.0
52 last_beat = 0
53 if count % FS == 0:
54 print("Parmak yok / No finger")
55 continue
56 if dc == 0.0:
57 dc = ir
58 dc += 0.05 * (ir - dc) # yavaş ortalama = DC / slow average = DC
59 ac = dc - ir # kan dolunca ışık azalır / light drops as blood fills
60 reds.append(red)
61 irs.append(ir)
62 if len(irs) > WIN:
63 reds.pop(0)
64 irs.pop(0)
65 thr = (max(irs) - min(irs)) * 0.2 # uyarlanır eşik / adaptive threshold
66 if not above and ac > thr and count - last_beat > FS * 0.3:
67 above = True
68 if last_beat:
69 bpm = 60 * FS / (count - last_beat)
70 if 40 <= bpm <= 200:
71 beats.append(bpm)
72 if len(beats) > 4:
73 beats.pop(0)
74 last_beat = count
75 elif ac < 0:
76 above = False
77 if count % FS == 0 and len(irs) == WIN and beats:
78 ac_r = max(reds) - min(reds)
79 ac_i = max(irs) - min(irs)
80 if ac_i > 0:
81 R = (ac_r / (sum(reds) / WIN)) / (ac_i / (sum(irs) / WIN))
82 spo2 = min(100, -45.060 * R * R + 30.354 * R + 94.845)
83 print("BPM: %d SpO2: %d %%" % (int(sum(beats) / len(beats)), int(spo2)))
84 time.sleep_ms(20)El código comprueba primero que el registro PART_ID valga 0x15; ese valor indica que el sensor es de verdad un MAX30102. El 0x27 escrito en el registro 0x0A reúne en un solo byte el rango de ADC de 4096 nA, la frecuencia de muestreo de 100 Hz y el ancho de pulso de 411 µs. En modo SpO2 cada muestra del FIFO ocupa 6 bytes: los 3 primeros son la medida roja y los 3 siguientes la IR, y cada una es un número de 18 bits. Para detectar latidos se resta a la señal IR su media lenta (DC) y queda solo la onda del pulso (AC); se cuenta un latido cuando la onda supera el 20 % de la amplitud de la ventana y se esperan al menos 300 ms entre dos latidos, lo que permite un máximo de 200 BPM. Aquí la SpO2 se calcula con un método simple de pico a pico, así que es solo un valor aproximado con fines educativos.
Colocación correcta del dedo y error por movimiento
- Usa la yema del dedo: coloca la parte blanda de la yema del índice o del corazón sobre los LED, justo en el lado opuesto a la uña.
- Presiona suavemente: apretar demasiado aleja la sangre de los capilares y la onda se reduce; sujetar demasiado flojo deja entrar luz ambiente. Una presión suave y constante con una banda elástica o una tira de velcro da el mejor resultado.
- Bloquea la luz ambiente: la luz solar y los fluorescentes se cuelan en el sensor y estropean la señal; cubrir el dedo y el sensor con una funda de color oscuro mejora claramente la medida.
- Calienta el dedo: en un dedo frío el flujo de sangre es menor y la señal se debilita. Frotarte las manos unos segundos antes de medir ya marca la diferencia.
- Mantén fijos el cable y la placa: un módulo que se balancea en la protoboard añade ruido con cada roce; fija el sensor a la mesa o a una caja.
- Hablar y moverte: mover el dedo, hablar o subir y bajar el brazo durante la medida provoca una variación mucho mayor que la onda del pulso.
El error por movimiento es el mayor problema de los proyectos con MAX30102. La onda del pulso representa solo un 1–2 % de la luz total que mide el sensor; un desplazamiento del dedo de unos milímetros provoca un cambio mucho mayor y el algoritmo confunde esa variación con un latido. El resultado es que en el Monitor Serie ves de pronto valores irreales como 150 o 40 BPM. Para reducirlo, mide quieto, haz la media de varios resultados y descarta sin mostrarlos los resultados no válidos (valid = 0). En proyectos más avanzados se usan medias móviles, medianas o filtros paso banda; puedes encontrar sus equivalentes en Arduino en filtrado de datos de sensores.
Ideas de proyectos con el MAX30102
- Monitor de pulso de escritorio: muestra BPM y SpO2 con dígitos grandes y una onda de pulso deslizante en una pantalla OLED SSD1306.
- Sonido de latido: haz sonar un "bip" corto con un zumbador en cada latido y consigue la sensación de un pulsioxímetro de farmacia.
- Prueba de recuperación tras el deporte: mide el pulso justo después del ejercicio y un minuto más tarde, y calcula la diferencia.
- Registrador de datos: guarda las medidas con su marca de tiempo en una tarjeta SD y luego grafícalas en el ordenador.
- Sistema de avisos con ESP32: cuando termine la medida, envía el resultado como mensaje a tu móvil con un bot de Telegram.
- Comparación para la feria de ciencias: pon a funcionar a la vez un sensor de pulso analógico y el MAX30102 y haz una tabla de cuál da resultados más estables.
Errores comunes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| "MAX30102 no encontrado" | SDA y SCL invertidos, VIN sin conectar o pull-ups a 1,8 V | Revisa los cables, busca 0x57 con un escáner I2C, pasa el puente de soldadura a 3,3 V |
| El valor de IR siempre está por debajo de 50.000 | El dedo no está justo encima del sensor o la corriente de los LED es muy baja | Centra el dedo sobre los LED y aumenta ledBrightness |
| Los valores están cerca de 262.143 y no cambian | El ADC está saturado, la luz es demasiado fuerte | Baja ledBrightness o pon adcRange en 8192 o 16384 |
| El BPM salta entre 40 y 180 | Movimiento, presión excesiva o luz ambiente | Fija el dedo, presiona suavemente, protege el sensor de la luz |
| La SpO2 siempre es "--" o -999 | El algoritmo considera la señal no válida (validSpo2 = 0) | No te muevas durante 4 segundos, calienta el dedo y sujétalo con una banda |
| En el Uno el código se cuelga o se comporta raro | RAM insuficiente, hay otras librerías grandes cargadas | Mantén los búferes de 16 bits, pon los textos dentro de F() o pasa a un ESP32 |
El MAX30102 es un sensor excelente para aprender lo elegante que puede ser leer nuestro cuerpo con luz de dos colores y un algoritmo inteligente; solo recuerda interpretar las medidas como datos de un experimento y no como resultados médicos. Si quieres afianzar la lectura de sensores por I2C, mostrar valores en pantalla y guardar datos, en la app de BlueGrays puedes explorar proyectos de medida como DHT11, LDR, LCD I2C, estación meteorológica con OLED y registrador de temperatura, paso a paso con esquemas de conexión y códigos listos.
Preguntas frecuentes
¿Qué precisión tiene la SpO2 medida con el MAX30102?
Como los módulos de aficionado no están calibrados, la SpO2 puede desviarse varios puntos respecto a un pulsioxímetro homologado, y el movimiento y la luz ambiente aumentan aún más la diferencia. Los resultados son para experimentar y aprender; no deben usarse para decisiones de salud.
¿El MAX30102 funciona a 5 V?
Como los módulos MAX30102 habituales llevan regulador, el pin VIN se puede alimentar con 3,3 V o 5 V. Pero en algunas placas las resistencias pull-up del I2C están conectadas a 1,8 V y un Uno de 5 V puede no ver el sensor; en ese caso hay que pasar el puente de soldadura de la placa al lado de 3,3 V.
¿Qué diferencia hay entre el MAX30100 y el MAX30102?
Ambos miden pulso y SpO2 con LED rojo e IR. El MAX30102 es el chip más nuevo: ofrece ADC de hasta 18 bits, FIFO de 32 muestras y menor consumo. En el MAX30100 el ADC llega hasta 16 bits y el FIFO es de 16 muestras.
¿Por qué el MAX30102 da el error "sensor not found"?
Las causas más frecuentes son SDA y SCL invertidos, VIN o GND sin conectar y pull-ups conectados a 1,8 V. Ejecuta un escáner I2C y comprueba si aparece la dirección 0x57; si no aparece, el problema está en la conexión y no en el código.
¿Cuáles son los valores normales de pulso y SpO2?
En adultos en reposo el pulso suele estar entre 60 y 100 latidos por minuto, y puede ser más bajo en deportistas. En personas sanas la SpO2 suele estar entre el 95 % y el 100 %. Si con tu sensor de aficionado ves un valor fuera de ese rango, revisa primero las condiciones de medida y, ante una duda real, acude a un dispositivo homologado.
¿Puede el MAX30102 medir en la muñeca o en la oreja?
Como el sensor trabaja por reflexión, también puede captar la onda del pulso en la muñeca o el lóbulo de la oreja, pero en esas zonas la señal es mucho más débil que en la yema del dedo y más sensible al movimiento. Por eso los relojes inteligentes usan LED más potentes, corrección de movimiento con acelerómetro y algoritmos avanzados.
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…

HC-SR04 Medición de distancia (pantalla en serie)
El sensor HC-SR04 funciona igual que un murciélago que se orienta en la oscuridad: emite un sonido que no puedes oír, escucha el eco y mide a qué distancia está el objeto que tiene delante.

Medir la intensidad de luz con LDR
¿Quieres ver en números cuánta luz hay en tu habitación? El LDR, una pequeña pieza sensible a la luz, mide la luz ambiente y el Arduino escribe el valor en la pantalla del ordenador cada medio…

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 HTTPClient + API del tiempo (con pantalla OLED SSD1306)
El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. A diferencia de la versión con LCD I2C, aquí usamos una pantalla OLED SSD1306 (128×64), con letra grande e iconos vectoriales para una vista más rica. Siete iconos del tiempo (soleado, lluvia, nieve y más) se dibujan al momento, sin archivos bitmap.

Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
El modo Deep Sleep del ESP32 apaga la CPU y la mayoría de los periféricos y reduce el consumo a unos 10µA, algo clave para dispositivos IoT con batería. Este proyecto usa tres fuentes de activación: un temporizador (15 s), un pin externo (EXT0, el botón en GPIO 33) y un pin táctil (T0/GPIO 4). Los contadores marcados con RTC_DATA_ATTR se conservan durante el deep sleep.

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

