Componentes · 10 min de lectura

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.

El módulo MAX30102 y los códigos de este artículo no son un dispositivo médico. No diagnostiques ni tomes decisiones sobre medicación o tratamiento con los valores de pulso y SpO2 de un circuito de aficionado sin calibrar ni homologar. Si tienes cualquier duda sobre tu salud, usa un dispositivo homologado y consulta a un profesional sanitario.

¿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ísticaValor
FabricanteMaxim Integrated (hoy Analog Devices)
LEDRojo 660 nm, infrarrojo (IR) 880 nm
ADCResolución de hasta 18 bits, 50–3200 muestras/segundo
MemoriaFIFO de 32 muestras
InterfazI2C, dirección 0x57 (en notación de 8 bits: escritura 0xAE, lectura 0xAF), hasta 400 kHz
Alimentación del chipNúcleo 1,8 V, LED 3,1–5 V
Alimentación del móduloVIN 3,3–5 V (la placa lleva reguladores)
Corriente de los LEDSe ajusta por software entre 0 y 50 mA (pasos de 0,2 mA)
Corriente en modo apagadoAprox. 0,7 µA
Función extraSensor de temperatura interno que mide la temperatura del chip

Diferencias entre MAX30102, MAX30100 y los sensores de pulso analógicos

CaracterísticaMAX30102MAX30100Pulse Sensor / KY-039
Qué midePulso + SpO2Pulso + SpO2Solo pulso
SalidaI2C (digital)I2C (digital)Tensión analógica
Resolución del ADCHasta 18 bitsHasta 16 bitsEl ADC del microcontrolador
FIFO32 muestras16 muestrasNo tiene
Fuente de luzRojo + IRRojo + IRLED verde o LED IR
Complejidad del códigoFácil con libreríaFácil con libreríaLa más simple con analogRead
Sensor de pulso analógico Pulse Sensor
El Pulse Sensor analógico solo mide el pulso; para la SpO2 hace falta un sensor de dos colores como el MAX30102.

Pines del MAX30102 y tabla de conexión

Pin del MAX30102Arduino UnoESP32Raspberry Pi Pico
VIN5V (o 3.3V)3V33V3(OUT) (pin 36)
GNDGNDGNDGND
SCLA5GPIO 22GP5 (pin 7)
SDAA4GPIO 21GP4 (pin 6)
INTPuede quedar sin conectarPuede quedar sin conectarPuede quedar sin conectar
IRD / RDDéjalo libreDéjalo libreDéjalo libre
En algunas placas MAX30102 moradas baratas, las resistencias pull-up de SDA y SCL están conectadas a la línea de 1,8 V. Estas placas pueden dar el error "sensor no encontrado" en un Uno de 5 V. Si la placa tiene un puente de soldadura de tres puntos, cámbialo al lado de 3,3 V; además, invertir SDA y SCL es la causa más frecuente de este error.

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

  1. En el IDE de Arduino abre el Gestor de bibliotecas y escribe SparkFun MAX3010x.
  2. 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.
  3. 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.
  4. 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

C++ (Arduino IDE)
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.
Pon el Monitor Serie a 115200 baudios y, tras colocar el dedo en el sensor, espera 10–15 segundos sin moverte; el promedio solo se estabiliza después de varios latidos correctos. Si usas el Serial Plotter para ver el valor de IR en el tiempo, podrás seguir la onda del pulso a simple vista.

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.

C++ (Arduino IDE)
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ódigoOpciones
ledBrightness60 (unos 12 mA)0 = apagado … 255 = 50 mA
sampleAverage41, 2, 4, 8, 16, 32
ledMode2 (rojo + IR)1 = solo rojo, 2 = rojo + IR, 3 = también verde (solo MAX30105)
sampleRate10050, 100, 200, 400, 800, 1000, 1600, 3200
pulseWidth411 µs (18 bits)69, 118, 215, 411 µs
adcRange4096 nA2048, 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.

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íntomaCausa probableSolución
"MAX30102 no encontrado"SDA y SCL invertidos, VIN sin conectar o pull-ups a 1,8 VRevisa 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.000El dedo no está justo encima del sensor o la corriente de los LED es muy bajaCentra el dedo sobre los LED y aumenta ledBrightness
Los valores están cerca de 262.143 y no cambianEl ADC está saturado, la luz es demasiado fuerteBaja ledBrightness o pon adcRange en 8192 o 16384
El BPM salta entre 40 y 180Movimiento, presión excesiva o luz ambienteFija el dedo, presiona suavemente, protege el sensor de la luz
La SpO2 siempre es "--" o -999El 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 raroRAM insuficiente, hay otras librerías grandes cargadasMantén los búferes de 16 bits, pon los textos dentro de F() o pasa a un ESP32
Antes de empezar a medir, observa el valor IR en bruto en el Serial Plotter. Si al poner el dedo el valor supera las 50.000 y dibuja pequeñas ondas regulares, la conexión y la colocación son correctas; si no ves ondas, ajusta la corriente de los LED y la presión del dedo antes de culpar al algoritmo.

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.

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
HC-SR04 Medición de distancia (pantalla en serie)
AR-27Principiante

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.

4.6(50)
82
Medir la intensidad de luz con LDR
AR-11Principiante

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…

4.6(83)
143
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 HTTPClient + API del tiempo (con pantalla OLED SSD1306)
ES-32Avanzado
Premium

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.

4.3(10)
22
Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
ES-33Avanzado
Premium

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.

4.3(10)
16
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