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.
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.
| Caratteristica | Valore |
|---|---|
| Produttore | Maxim Integrated (oggi Analog Devices) |
| LED | Rosso 660 nm, infrarosso (IR) 880 nm |
| ADC | Fino a 18 bit, 50–3200 campioni/secondo |
| Memoria | FIFO da 32 campioni |
| Interfaccia | I2C, indirizzo 0x57 (a 8 bit: scrittura 0xAE, lettura 0xAF), fino a 400 kHz |
| Alimentazione del chip | Core 1,8 V, LED 3,1–5 V |
| Alimentazione del modulo | VIN 3,3–5 V (sulla scheda ci sono i regolatori) |
| Corrente dei LED | Regolabile via software da 0 a 50 mA (passi da 0,2 mA) |
| Corrente in spegnimento | Circa 0,7 µA |
| Funzione extra | Sensore di temperatura interno che misura la temperatura del chip |
Differenze tra MAX30102, MAX30100 e sensori di battito analogici
| Caratteristica | MAX30102 | MAX30100 | Pulse Sensor / KY-039 |
|---|---|---|---|
| Cosa misura | Battito + SpO2 | Battito + SpO2 | Solo battito |
| Uscita | I2C (digitale) | I2C (digitale) | Tensione analogica |
| Risoluzione ADC | Fino a 18 bit | Fino a 16 bit | ADC del microcontrollore |
| FIFO | 32 campioni | 16 campioni | Assente |
| Sorgente di luce | Rosso + IR | Rosso + IR | LED verde o LED IR |
| Complessità del codice | Facile con la libreria | Facile con la libreria | Il più semplice con analogRead |

Pin del MAX30102 e tabella dei collegamenti
| Pin 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 | Si può lasciare scollegato | Si può lasciare scollegato | Si può lasciare scollegato |
| IRD / RD | Lascia libero | Lascia libero | Lascia libero |
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
- Nell'IDE di Arduino apri il Gestore librerie e cerca SparkFun MAX3010x.
- 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.
- 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.
- 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
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 codice | Cosa 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. |
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.
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 codice | Opzioni |
|---|---|---|
| ledBrightness | 60 (circa 12 mA) | 0 = spento … 255 = 50 mA |
| sampleAverage | 4 | 1, 2, 4, 8, 16, 32 |
| ledMode | 2 (rosso + IR) | 1 = solo rosso, 2 = rosso + IR, 3 = anche verde (solo MAX30105) |
| sampleRate | 100 | 50, 100, 200, 400, 800, 1000, 1600, 3200 |
| pulseWidth | 411 µs (18 bit) | 69, 118, 215, 411 µs |
| adcRange | 4096 nA | 2048, 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.
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
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| "MAX30102 non trovato" | SDA e SCL scambiati, VIN non collegato o pull-up a 1,8 V | Controlla i cavi, cerca 0x57 con lo scanner I2C, sposta il ponte di saldatura su 3,3 V |
| Il valore IR resta sempre sotto 50.000 | Il dito non è esattamente sopra il sensore o la corrente dei LED è troppo bassa | Centra il dito sui LED, aumenta il valore di ledBrightness |
| I valori sono vicini a 262.143 e non cambiano | L'ADC è saturo, la luce è troppo forte | Diminuisci ledBrightness oppure porta adcRange a 8192 o 16384 |
| Il BPM salta tra 40 e 180 | Movimento, pressione eccessiva o luce ambientale | Fissa il dito, premi leggermente, proteggi il sensore dalla luce |
| La SpO2 è sempre "--" oppure -999 | L'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 strano | RAM insufficiente, sono caricate anche altre librerie grandi | Mantieni i buffer a 16 bit, metti i testi dentro F() oppure passa a un ESP32 |
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.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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…

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

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…

Utilizzo dello schermo LCD con I2C
Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

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

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.

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.

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.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

