Componenti · 9 min di lettura

Sensore MAX30102 Arduino: battito cardiaco e SpO2, collegamenti

Sensore MAX30102 con Arduino: collegamento I2C (0x57), LED rosso e IR, libreria SparkFun per battito e SpO2, con codice per Uno, ESP32 e Pico.

Il MAX30102 è un piccolo sensore ottico che nei progetti Arduino misura dalla punta del dito il battito cardiaco e la saturazione di ossigeno nel sangue (SpO2). In un unico chip trovi un LED rosso e uno a infrarossi (IR), un fotodiodo che rileva la luce, un ADC a 18 bit e una memoria (FIFO) che accumula le misure. Comunica con Arduino con soli due fili dati, cioè via I2C, quindi lo colleghi a Uno, ESP32 e Raspberry Pi Pico in pochi minuti. Il principio di funzionamento è lo stesso dei pulsossimetri da dito venduti in farmacia.

In questo articolo vedrai passo dopo passo come il MAX30102 misura battito e ossigeno con la luce, i pin del modulo e la tabella dei collegamenti per ogni scheda, come leggere il battito su Arduino Uno con la libreria SparkFun, come calcolare battito e SpO2 insieme su ESP32 e il codice MicroPython senza librerie per il Pico. Alla fine imparerai a sconfiggere i due nemici principali delle misure: il posizionamento sbagliato del dito e il movimento.

I moduli MAX30102 e i codici di questo articolo non sono dispositivi medici. Non usare i valori di battito e SpO2 di un circuito amatoriale non calibrato e non certificato per fare diagnosi o prendere decisioni su farmaci o cure. Se hai dubbi sulla tua salute, usa un dispositivo certificato e rivolgiti a un professionista sanitario.

Cos'è il MAX30102 e come funziona?

Il sensore invia luce rossa e a infrarossi sulla punta del dito, e il fotodiodo accanto misura la luce riflessa dal tessuto. Poiché LED e rilevatore stanno sulla stessa faccia, si parla di misura a riflessione. A ogni battito i capillari del dito si riempiono un po' di più di sangue; il sangue assorbe la luce, quindi in quel momento al fotodiodo ne torna meno. Nel segnale compare così una piccola onda che sale e scende al ritmo del cuore. Questo metodo si chiama fotopletismografia (PPG). Misurando il tempo tra due battiti ottieni la frequenza: se i battiti arrivano a 0,8 secondi di distanza, il polso è 60 / 0,8 = 75 BPM (battiti al minuto).

La misura dell'ossigeno si basa sul diverso comportamento dei due colori nel sangue. L'emoglobina che ha legato ossigeno assorbe più luce infrarossa e meno luce rossa; quella che ha ceduto l'ossigeno assorbe più luce rossa. Per ciascun colore il sensore calcola il rapporto tra la variazione del segnale (AC) e il livello costante (DC) e divide i due rapporti: R = (AC_rosso / DC_rosso) / (AC_IR / DC_IR). Più R diminuisce, più SpO2 sale. L'algoritmo di esempio di Maxim trasforma R in percentuale con la formula SpO2 = −45,060·R² + 30,354·R + 94,845: per R = 0,5 si ottiene circa il 98,8 %, per R = 1 circa l'80 %. Da qui si capisce che un piccolo errore di misura significa uno scarto di qualche punto in SpO2.

CaratteristicaValore
ProduttoreMaxim Integrated (oggi Analog Devices)
LEDRosso 660 nm, infrarosso (IR) 880 nm
ADCFino a 18 bit, 50–3200 campioni/secondo
MemoriaFIFO da 32 campioni
InterfacciaI2C, indirizzo 0x57 (a 8 bit: scrittura 0xAE, lettura 0xAF), fino a 400 kHz
Alimentazione del chipCore 1,8 V, LED 3,1–5 V
Alimentazione del moduloVIN 3,3–5 V (sulla scheda ci sono i regolatori)
Corrente dei LEDRegolabile via software da 0 a 50 mA (passi da 0,2 mA)
Corrente in spegnimentoCirca 0,7 µA
Funzione extraSensore di temperatura interno che misura la temperatura del chip

Differenze tra MAX30102, MAX30100 e sensori di battito analogici

CaratteristicaMAX30102MAX30100Pulse Sensor / KY-039
Cosa misuraBattito + SpO2Battito + SpO2Solo battito
UscitaI2C (digitale)I2C (digitale)Tensione analogica
Risoluzione ADCFino a 18 bitFino a 16 bitADC del microcontrollore
FIFO32 campioni16 campioniAssente
Sorgente di luceRosso + IRRosso + IRLED verde o LED IR
Complessità del codiceFacile con la libreriaFacile con la libreriaIl più semplice con analogRead
Sensore di battito analogico Pulse Sensor
Il Pulse Sensor analogico misura solo il battito; per la SpO2 serve un sensore a due colori come il MAX30102.

Pin del MAX30102 e tabella dei collegamenti

Pin MAX30102Arduino UnoESP32Raspberry Pi Pico
VIN5V (o 3.3V)3V33V3(OUT) (pin 36)
GNDGNDGNDGND
SCLA5GPIO 22GP5 (pin 7)
SDAA4GPIO 21GP4 (pin 6)
INTSi può lasciare scollegatoSi può lasciare scollegatoSi può lasciare scollegato
IRD / RDLascia liberoLascia liberoLascia libero
Su alcune schede MAX30102 viola economiche in commercio le resistenze di pull-up di SDA e SCL sono collegate alla linea a 1,8 V. Queste schede possono dare l'errore "sensore non trovato" su un Uno a 5 V. Se sulla scheda c'è un ponte di saldatura a tre punti, spostalo sul lato 3,3 V; inoltre, scambiare SDA e SCL è la causa più frequente di questo errore.

L'indirizzo I2C del sensore è fisso: 0x57. Se non sei sicuro dei cavi, puoi eseguire uno sketch di scansione I2C e verificare che l'indirizzo compaia nell'elenco; come funziona la linea I2C lo spieghiamo nel dettaglio nell'articolo Cos'è l'I2C?. Il pin INT è un'uscita di interrupt che passa a LOW quando ci sono nuovi dati; i codici di questo articolo interrogano il sensore in continuazione, quindi questo pin non serve. I pin IRD e RD sono i terminali di pilotaggio dei LED e nell'uso normale restano liberi.

Installazione della libreria: SparkFun MAX3010x

  1. Nell'IDE di Arduino apri il Gestore librerie e cerca SparkFun MAX3010x.
  2. Installa la libreria SparkFun MAX3010x Pulse and Proximity Sensor Library. Anche se nel nome compare MAX30105, funziona perfettamente con il MAX30102; nel MAX30102 manca solo il LED verde.
  3. La libreria include tre file: MAX30105.h, che pilota il sensore, heartRate.h, che rileva i battiti, e spo2_algorithm.h, con l'algoritmo SpO2 di Maxim.
  4. Se sei alle prime armi con l'installazione delle librerie, dai un'occhiata a Come aggiungere una libreria ad Arduino.

Misurare il battito (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}
Parte di codiceCosa fa
sensor.begin(Wire, I2C_SPEED_FAST)Avvia il sensore con I2C a 400 kHz; se non lo trova restituisce false.
sensor.setup(0x1F, 4, 2, 400, 411, 4096)Imposta corrente dei LED a circa 6,2 mA, media su 4 campioni, modalità rosso + IR, 400 campioni/s, impulso da 411 µs e intervallo ADC di 4096 nA.
sensor.getIR()Restituisce l'ultima misura a infrarossi; con il dito appoggiato di solito supera 50.000.
checkForBeat(ir)Restituisce true quando individua il picco di un battito nel segnale.
60.0 / (delta / 1000.0)Converte i millisecondi tra due battiti in battiti al minuto.
array rates[]Fa la media delle ultime 4 misure per attenuare i valori che saltano.
Imposta il Monitor seriale a 115200 baud e, dopo aver appoggiato il dito sul sensore, resta fermo 10–15 secondi: la media si assesta solo dopo alcuni battiti regolari. Se vuoi vedere l'IR nel tempo, usa il Serial Plotter e potrai seguire anche a occhio l'onda del battito.

Leggere battito e SpO2 insieme (ESP32 e Uno)

Per misurare l'ossigeno non basta contare i picchi: servono alcuni secondi di registrazione dei segnali rosso e IR. Il codice qui sotto è impostato per 25 campioni al secondo (misura a 100 Hz, media su 4) e riempie una finestra di 100 campioni, cioè 4 secondi. Poi l'algoritmo di Maxim calcola da questa finestra sia il battito sia la SpO2. Nei giri successivi scarta i 25 campioni più vecchi e ne aggiunge 25 nuovi, così ottieni un nuovo risultato ogni secondo. Poiché i 2 KB di RAM dell'Uno sono pochi per due array a 32 bit, su Uno il codice passa automaticamente ad array a 16 bit; lo stesso fa l'esempio ufficiale di SparkFun.

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}
Parametro di setup()Valore in questo codiceOpzioni
ledBrightness60 (circa 12 mA)0 = spento … 255 = 50 mA
sampleAverage41, 2, 4, 8, 16, 32
ledMode2 (rosso + IR)1 = solo rosso, 2 = rosso + IR, 3 = anche verde (solo MAX30105)
sampleRate10050, 100, 200, 400, 800, 1000, 1600, 3200
pulseWidth411 µs (18 bit)69, 118, 215, 411 µs
adcRange4096 nA2048, 4096, 8192, 16384

MAX30102 con ESP32

Il codice SpO2 qui sopra funziona sull'ESP32 senza modifiche; i pin I2C predefiniti sono GPIO 21 (SDA) e GPIO 22 (SCL) e, usando solo la libreria Wire, compila allo stesso modo con le versioni 2.x e 3.x del core Arduino per ESP32. Alimenta sempre il modulo dal pin 3V3, così le linee I2C restano a 3,3 V. L'abbondante RAM dell'ESP32 lascia spazio ai buffer a 32 bit, e il secondo core e il Wi-Fi rendono facile portare le misure su telefono o internet. Puoi per esempio mostrare i risultati su un display OLED, inviarli al telefono via Bluetooth BLE o misurare a intervalli brevi passando nel mezzo in deep sleep per allungare la durata della batteria. OLED e sensore possono condividere la stessa linea I2C; gli indirizzi sono diversi (0x3C e 0x57), quindi non ci sono conflitti.

Raspberry Pi Pico e MicroPython con il MAX30102

Per MicroPython non esiste un driver ufficiale già pronto per il MAX30102, ma i registri del sensore sono semplici e puoi gestirli da solo con poche righe. Il codice qui sotto imposta il sensore in modalità SpO2, legge dalla FIFO i campioni rosso e IR, rileva i battiti dal segnale IR e, da una finestra di 4 secondi, calcola il rapporto R e stampa una SpO2 approssimata. Se sei nuovo a Pico e MicroPython, guarda prima Cos'è Raspberry Pi Pico? e Le basi di 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)

Nel codice si controlla prima che il registro PART_ID valga 0x15: questo valore indica che il sensore è davvero un MAX30102. Il valore 0x27 scritto nel registro 0x0A riunisce in un solo byte l'intervallo ADC di 4096 nA, la frequenza di 100 Hz e l'impulso da 411 µs. In modalità SpO2 ogni campione della FIFO occupa 6 byte: i primi 3 sono la misura rossa, i successivi 3 quella IR, ciascuna un numero a 18 bit. Per rilevare i battiti si sottrae la media lenta (DC) del segnale IR, lasciando solo l'onda del battito (AC); si conta un battito quando l'onda supera il 20 % dell'ampiezza della finestra e si attendono almeno 300 ms tra due battiti, il che consente al massimo 200 BPM. Qui la SpO2 è calcolata con un semplice metodo picco-picco, quindi è solo un valore approssimato a scopo didattico.

Posizionamento corretto del dito ed errori da movimento

  • Usa la punta del dito: appoggia la parte morbida dell'indice o del medio sui LED, proprio di fronte all'unghia.
  • Premi leggermente: premere troppo forte allontana il sangue dai capillari e l'onda si riduce; tenere il dito troppo lento lascia entrare la luce ambientale. Un elastico o una fascia in velcro che dia una pressione leggera e costante dà i risultati migliori.
  • Blocca la luce ambientale: luce solare e lampade fluorescenti filtrano nel sensore e disturbano il segnale; coprire dito e sensore con una guaina scura migliora nettamente la misura.
  • Scalda il dito: con il dito freddo il flusso di sangue diminuisce e il segnale si indebolisce. Anche strofinare le mani per qualche secondo prima della misura fa la differenza.
  • Cavi e scheda fermi: un modulo che ballonzola sulla breadboard aggiunge rumore al segnale a ogni tocco; fissa il sensore al tavolo o dentro una scatola.
  • Parlare e muoversi: muovere il dito, parlare o alzare e abbassare il braccio durante la misura crea oscillazioni molto più grandi dell'onda del battito.

L'errore da movimento è il problema più grande nei progetti con il MAX30102. L'onda del battito è solo circa l'1–2 % della luce totale misurata dal sensore; uno spostamento del dito di pochi millimetri provoca una variazione molto più grande e l'algoritmo scambia questa oscillazione per un battito. Il risultato è che nel Monitor seriale vedi all'improvviso valori irreali come 150 o 40 BPM. Per ridurre il problema, misura stando fermo, fai la media di più risultati e scarta senza mostrarli quelli non validi (valid = 0). Nei progetti più avanzati si usano media mobile, mediana o filtri passa-banda; trovi gli equivalenti su Arduino nell'articolo filtrare i dati dei sensori.

Idee di progetto con il MAX30102

  • Indicatore da scrivania: mostra BPM e SpO2 con cifre grandi e un'onda del battito scorrevole su un display OLED SSD1306.
  • Suono del battito: a ogni battito fai suonare un breve "bip" con un buzzer e ottieni l'effetto del pulsossimetro da farmacia.
  • Test di recupero dopo lo sport: misura il battito subito dopo l'esercizio e dopo 1 minuto, poi calcola la differenza.
  • Registratore di dati: scrivi le misure con data e ora su una scheda SD e poi tracciane il grafico sul computer.
  • Sistema di notifica con ESP32: a misura completata invia il risultato come messaggio al telefono con un bot Telegram.
  • Confronto per la fiera della scienza: fai funzionare insieme un sensore di battito analogico e il MAX30102 e metti in tabella quale dà risultati più stabili.

Errori comuni e come risolverli

SintomoCausa probabileSoluzione
"MAX30102 non trovato"SDA e SCL scambiati, VIN non collegato o pull-up a 1,8 VControlla i cavi, cerca 0x57 con lo scanner I2C, sposta il ponte di saldatura su 3,3 V
Il valore IR resta sempre sotto 50.000Il dito non è esattamente sopra il sensore o la corrente dei LED è troppo bassaCentra il dito sui LED, aumenta il valore di ledBrightness
I valori sono vicini a 262.143 e non cambianoL'ADC è saturo, la luce è troppo forteDiminuisci ledBrightness oppure porta adcRange a 8192 o 16384
Il BPM salta tra 40 e 180Movimento, pressione eccessiva o luce ambientaleFissa il dito, premi leggermente, proteggi il sensore dalla luce
La SpO2 è sempre "--" oppure -999L'algoritmo considera il segnale non valido (validSpo2 = 0)Resta fermo per 4 secondi, scalda il dito e fissalo con una fascia
Su Uno il codice si blocca o si comporta in modo stranoRAM insufficiente, sono caricate anche altre librerie grandiMantieni i buffer a 16 bit, metti i testi dentro F() oppure passa a un ESP32
Prima di iniziare a misurare, osserva il valore IR grezzo del sensore nel Serial Plotter. Se quando appoggi il dito il valore supera 50.000 e disegna piccole onde regolari, collegamento e posizionamento sono corretti; se non vedi onde, prima di dare la colpa all'algoritmo regola la corrente dei LED e la pressione del dito.

Il MAX30102 è un ottimo sensore per imparare, perché mostra con quanta eleganza si può leggere il corpo con due colori di luce e un algoritmo intelligente; l'importante è interpretare le misure come dati sperimentali, non come risultati medici. Se vuoi consolidare la lettura dei sensori via I2C, la visualizzazione dei valori su display e la registrazione dei dati, nell'app BlueGrays trovi passo dopo passo progetti di misura come DHT11, LDR, LCD I2C, meteo su OLED e registratore di temperatura, con schemi elettrici e codice pronto.

Domande frequenti

Quanto è accurata la SpO2 misurata con il MAX30102?

I moduli amatoriali non sono calibrati, quindi la SpO2 può scostarsi di qualche punto rispetto a un pulsossimetro certificato; movimento e luce ambientale peggiorano ancora la differenza. I risultati servono per esperimenti e apprendimento e non vanno usati per decisioni sulla salute.

Il MAX30102 funziona a 5 V?

Sui moduli MAX30102 più diffusi c'è un regolatore, quindi il pin VIN può essere alimentato a 3,3 V o a 5 V. Però su alcune schede le pull-up I2C sono collegate a 1,8 V e un Uno a 5 V potrebbe non vedere il sensore; in quel caso devi spostare il ponte di saldatura sul lato 3,3 V.

Qual è la differenza tra MAX30100 e MAX30102?

Entrambi misurano battito e SpO2 con LED rosso e IR. Il MAX30102 è il chip più recente: offre un ADC fino a 18 bit, una FIFO da 32 campioni e un consumo inferiore. Nel MAX30100 l'ADC arriva a 16 bit e la FIFO è di 16 campioni.

Perché il MAX30102 dà l'errore "sensor not found"?

Le cause più frequenti sono SDA e SCL collegati al contrario, VIN o GND mancanti e pull-up collegate a 1,8 V. Esegui uno sketch di scansione I2C e controlla se compare l'indirizzo 0x57; se non compare, il problema è nei collegamenti, non nel codice.

Quali sono i valori normali di battito e SpO2?

In un adulto a riposo il battito è di solito tra 60 e 100 battiti al minuto, e può essere più basso negli sportivi. In una persona sana la SpO2 è di solito tra il 95 % e il 100 %. Se con il tuo sensore amatoriale vedi valori fuori da questi intervalli, controlla prima le condizioni di misura; se hai un dubbio reale, rivolgiti a un dispositivo certificato.

Il MAX30102 può misurare dal polso o dall'orecchio?

Poiché il sensore lavora a riflessione, può rilevare l'onda del battito anche al polso o sul lobo dell'orecchio, ma in quelle zone il segnale è molto più debole rispetto alla punta del dito e più sensibile al movimento. Per questo gli smartwatch usano LED più potenti, correzione del movimento con accelerometro e algoritmi avanzati.

Vedi tutti i progetti
Temperatura e umidità con DHT11
AR-55Intermedio

Temperatura e umidità con DHT11

Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

4.7(47)
83
HC-SR04 Misura della distanza (display seriale)
AR-27Principiante

HC-SR04 Misura della distanza (display seriale)

Il sensore HC-SR04 funziona come un pipistrello che trova la strada al buio: manda un suono che non puoi sentire, ne ascolta l'eco e misura quanto è lontano l'oggetto davanti a sé.

4.6(50)
82
Misurare l'intensità luminosa con LDR
AR-11Principiante

Misurare l'intensità luminosa con LDR

Vuoi vedere quanto è luminosa la tua stanza sotto forma di numero? L'LDR, un piccolo componente sensibile alla luce, misura la luce ambiente e l'Arduino scrive il valore sullo schermo del computer…

4.6(83)
143
Utilizzo dello schermo LCD con I2C
AR-32Principiante
Premium

Utilizzo dello schermo LCD con I2C

Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

4.8(53)
70
Schermo LCD I2C per ESP32 (16x2)
ES-17Intermedio
Premium

Schermo LCD I2C per ESP32 (16x2)

In questo progetto colleghiamo un display LCD 16x2 a caratteri all'ESP32 tramite I2C per mostrare del testo. Con l'I2C bastano 2 pin dati (SDA e SCL) invece dei 6+ pin di un collegamento parallelo classico. Il codice scrive un messaggio fisso sulla prima riga e un contatore che sale ogni secondo sulla seconda. All'avvio uno scanner I2C stampa l'indirizzo del display sul Serial Monitor (di solito 0x27 o 0x3F).

4.9(23)
40
ESP32 HTTPClient + API meteo (con display OLED SSD1306)
ES-32Avanzato
Premium

ESP32 HTTPClient + API meteo (con display OLED SSD1306)

L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. A differenza della versione con LCD I2C, qui usiamo un display OLED SSD1306 (128×64), con testo grande e icone vettoriali per una resa più ricca. Sette icone meteo (sole, pioggia, neve e altre) vengono disegnate al volo, senza file bitmap.

4.3(10)
22
ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
ES-33Avanzato
Premium

ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)

La modalità Deep Sleep dell'ESP32 spegne la CPU e quasi tutte le periferiche e riduce il consumo a circa 10µA, un aspetto cruciale per i dispositivi IoT a batteria. Il progetto usa tre sorgenti di risveglio: un timer (15 s), un pin esterno (EXT0, il pulsante su GPIO 33) e un pin touch (T0/GPIO 4). I contatori marcati con RTC_DATA_ATTR restano salvati durante il deep sleep.

4.3(10)
16
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

4.7(7)
12