MAX30102 Arduino: Puls und SpO2 messen, Anschluss und Code
MAX30102 am Arduino anschließen (I2C, 0x57), Puls und SpO2 mit der SparkFun-Bibliothek messen: Funktionsprinzip, Codes für Uno, ESP32 und Pico.
Der MAX30102 ist ein kleiner optischer Sensor, mit dem du in Arduino-Projekten am Fingerspitzen den Puls (Herzfrequenz) und die Sauerstoffsättigung im Blut (SpO2) misst. In einem einzigen Chip stecken eine rote und eine infrarote (IR) LED, eine Fotodiode, ein 18-Bit-ADC und ein Speicher (FIFO) für die Messwerte. Er kommuniziert mit dem Arduino über nur zwei Datenleitungen, also per I2C, und lässt sich deshalb in wenigen Minuten an Uno, ESP32 und Raspberry Pi Pico anschließen. Genau so funktionieren auch die Fingerpulsoximeter aus der Apotheke.
In diesem Beitrag siehst du Schritt für Schritt, wie der MAX30102 mit Licht Puls und Sauerstoff misst, welche Pins das Modul hat und wie du es je nach Board verkabelst. Du liest mit der SparkFun-Bibliothek den Puls am Arduino Uno aus, berechnest auf dem ESP32 Puls und SpO2 zusammen und nutzt auf dem Pico MicroPython-Code ohne Bibliothek. Zum Schluss lernst du, wie du die zwei größten Störfaktoren in den Griff bekommst: falsche Fingerlage und Bewegung.
Was ist der MAX30102 und wie funktioniert er?
Der Sensor sendet rotes und infrarotes Licht in die Fingerspitze, und die direkt daneben sitzende Fotodiode misst das vom Gewebe zurückgeworfene Licht. Weil LEDs und Detektor auf derselben Seite liegen, spricht man von einer Reflexionsmessung. Bei jedem Herzschlag füllen sich die Kapillaren im Finger etwas mehr mit Blut; Blut absorbiert Licht, deshalb sinkt in diesem Moment das Licht, das zur Fotodiode zurückkommt. Im Messsignal entsteht so eine kleine Welle, die im Takt des Herzschlags auf und ab geht. Dieses Verfahren heißt Photoplethysmographie (PPG). Misst du die Zeit zwischen zwei Schlägen, erhältst du den Puls: Kommen die Schläge im Abstand von 0,8 Sekunden, beträgt der Puls 60 / 0,8 = 75 BPM (Schläge pro Minute).
Die Sauerstoffmessung beruht darauf, dass sich die beiden Farben im Blut unterschiedlich verhalten. Sauerstoffreiches Hämoglobin absorbiert mehr Infrarotlicht und weniger rotes Licht; sauerstoffarmes Hämoglobin absorbiert mehr rotes Licht. Der Sensor bildet für beide Farben das Verhältnis aus Schwankung (AC) und konstantem Pegel (DC) und teilt die beiden Verhältnisse durcheinander: R = (AC_rot / DC_rot) / (AC_IR / DC_IR). Je kleiner R, desto höher die SpO2. Der Beispielalgorithmus von Maxim rechnet R mit der Formel SpO2 = −45,060·R² + 30,354·R + 94,845 in Prozent um; für R = 0,5 ergeben sich etwa 98,8 %, für R = 1 etwa 80 %. Daran siehst du: Schon ein kleiner Messfehler bedeutet mehrere Prozentpunkte Abweichung bei der SpO2.
| Eigenschaft | Wert |
|---|---|
| Hersteller | Maxim Integrated (heute Analog Devices) |
| LEDs | Rot 660 nm, Infrarot (IR) 880 nm |
| ADC | Bis zu 18 Bit Auflösung, 50–3200 Abtastungen/Sekunde |
| Speicher | FIFO mit 32 Abtastwerten |
| Schnittstelle | I2C, Adresse 0x57 (in 8-Bit-Schreibweise Schreiben 0xAE, Lesen 0xAF), bis 400 kHz |
| Chip-Versorgung | Kern 1,8 V, LEDs 3,1–5 V |
| Modul-Versorgung | VIN 3,3–5 V (auf der Platine sind Spannungsregler) |
| LED-Strom | 0–50 mA per Software einstellbar (in 0,2-mA-Schritten) |
| Strom im Shutdown | Etwa 0,7 µA |
| Zusatzfunktion | Integrierter Temperatursensor für die Chip-Temperatur |
Unterschied zwischen MAX30102, MAX30100 und analogen Pulssensoren
| Eigenschaft | MAX30102 | MAX30100 | Pulse Sensor / KY-039 |
|---|---|---|---|
| Misst | Puls + SpO2 | Puls + SpO2 | Nur Puls |
| Ausgang | I2C (digital) | I2C (digital) | Analoge Spannung |
| ADC-Auflösung | Bis zu 18 Bit | Bis zu 16 Bit | ADC des Mikrocontrollers |
| FIFO | 32 Werte | 16 Werte | Keiner |
| Lichtquelle | Rot + IR | Rot + IR | Grüne LED oder IR-LED |
| Code-Aufwand | Einfach mit Bibliothek | Einfach mit Bibliothek | Am einfachsten mit analogRead |

MAX30102-Pins und Anschlusstabelle
| MAX30102-Pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN | 5V (oder 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 | Kann offen bleiben | Kann offen bleiben | Kann offen bleiben |
| IRD / RD | Offen lassen | Offen lassen | Offen lassen |
Die I2C-Adresse des Sensors ist fest: 0x57. Bist du bei der Verkabelung unsicher, lass einen I2C-Scanner laufen und prüfe, ob diese Adresse auftaucht; wie der I2C-Bus funktioniert, erklären wir ausführlich im Beitrag Was ist I2C?. Der INT-Pin ist ein Interrupt-Ausgang, der auf LOW geht, wenn neue Daten bereit sind; da der Code in diesem Beitrag den Sensor ständig abfragt, brauchst du ihn nicht. IRD und RD sind die Treiberanschlüsse der LEDs und bleiben im Normalbetrieb frei.
Bibliothek installieren: SparkFun MAX3010x
- Öffne in der Arduino IDE den Bibliotheksverwalter und suche nach SparkFun MAX3010x.
- Installiere die SparkFun MAX3010x Pulse and Proximity Sensor Library. Obwohl MAX30105 im Namen steht, läuft sie 1:1 mit dem MAX30102; dem MAX30102 fehlt nur die grüne LED.
- Die Bibliothek bringt drei Dateien mit: MAX30105.h steuert den Sensor, heartRate.h erkennt den Pulsschlag und spo2_algorithm.h enthält den SpO2-Algorithmus von Maxim.
- Wenn du noch neu im Installieren von Bibliotheken bist, schau dir Bibliothek in Arduino hinzufügen an.
Puls (BPM) mit dem Arduino Uno messen
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}| Codeabschnitt | Was passiert? |
|---|---|
| sensor.begin(Wire, I2C_SPEED_FAST) | Startet den Sensor mit 400 kHz I2C; gibt false zurück, wenn er nicht gefunden wird. |
| sensor.setup(0x1F, 4, 2, 400, 411, 4096) | Wählt etwa 6,2 mA LED-Strom, Mittelung über 4 Werte, Modus Rot + IR, 400 Abtastungen/s, 411 µs Pulsbreite und 4096 nA ADC-Bereich. |
| sensor.getIR() | Liefert die letzte Infrarotmessung; mit Finger meist über 50.000. |
| checkForBeat(ir) | Gibt true zurück, wenn im Signal ein Pulsmaximum erkannt wurde. |
| 60.0 / (delta / 1000.0) | Rechnet die Millisekunden zwischen zwei Schlägen in Schläge pro Minute um. |
| rates[]-Array | Glättet springende Werte durch den Mittelwert der letzten 4 Messungen. |
Puls und SpO2 gemeinsam auslesen (ESP32 und Uno)
Für die Sauerstoffmessung reicht es nicht, nur Spitzen zu zählen; du brauchst eine Aufzeichnung der roten und IR-Signale über einige Sekunden. Der folgende Code ist auf 25 Abtastungen pro Sekunde eingestellt (100 Hz Messung, 4er-Mittelung) und füllt ein Fenster von 100 Werten, also 4 Sekunden. Danach berechnet der Maxim-Algorithmus aus diesem Fenster Puls und SpO2. In den folgenden Runden werden die ältesten 25 Werte verworfen und 25 neue ergänzt; so bekommst du jede Sekunde ein neues Ergebnis. Da die 2 KB RAM des Uno für zwei 32-Bit-Arrays zu knapp sind, wechselt der Code auf dem Uno automatisch auf 16-Bit-Arrays; das offizielle Beispiel von SparkFun geht genauso vor.
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}| setup()-Parameter | Wert in diesem Code | Optionen |
|---|---|---|
| ledBrightness | 60 (etwa 12 mA) | 0 = aus … 255 = 50 mA |
| sampleAverage | 4 | 1, 2, 4, 8, 16, 32 |
| ledMode | 2 (Rot + IR) | 1 = nur Rot, 2 = Rot + IR, 3 = auch Grün an (nur 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 mit dem ESP32
Der SpO2-Code oben läuft auf dem ESP32 ohne jede Änderung; die Standard-I2C-Pins sind GPIO 21 (SDA) und GPIO 22 (SCL), und da der Code nur die Wire-Bibliothek nutzt, lässt er sich mit dem ESP32-Arduino-Core in Version 2.x und 3.x identisch kompilieren. Versorge das Modul unbedingt über den 3V3-Pin, damit die I2C-Leitungen auf 3,3 V bleiben. Das reichlich vorhandene RAM des ESP32 bietet viel Platz für 32-Bit-Puffer, und mit dem zweiten Kern und WLAN kannst du die Messwerte leicht aufs Handy oder ins Internet bringen. Du kannst die Ergebnisse zum Beispiel auf einem OLED-Display anzeigen, per Bluetooth BLE ans Handy senden oder in kurzen Abständen messen und dazwischen in den Deep Sleep gehen, um den Akku zu schonen. OLED und Sensor können sich dieselbe I2C-Leitung teilen; die Adressen unterscheiden sich (0x3C und 0x57), also gibt es keinen Konflikt.
Raspberry Pi Pico und MicroPython mit dem MAX30102
Für MicroPython gibt es keinen fertigen offiziellen MAX30102-Treiber; da die Register des Sensors aber einfach sind, kannst du ihn mit wenigen Zeilen selbst ansteuern. Der folgende Code versetzt den Sensor in den SpO2-Modus, liest rote und IR-Werte aus dem FIFO, erkennt Schläge im IR-Signal und berechnet aus dem 4-Sekunden-Fenster das Verhältnis R und daraus eine ungefähre SpO2. Wenn du neu beim Pico und bei MicroPython bist, schau dir zuerst Was ist der Raspberry Pi Pico? und die MicroPython-Grundlagen an.
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)Im Code wird zuerst geprüft, ob das Register PART_ID den Wert 0x15 hat; das zeigt, dass der Sensor wirklich ein MAX30102 ist. Der in Register 0x0A geschriebene Wert 0x27 fasst 4096 nA ADC-Bereich, 100 Hz Abtastrate und 411 µs Pulsbreite in einem Byte zusammen. Im SpO2-Modus ist jeder FIFO-Eintrag 6 Bytes lang: die ersten 3 Bytes sind der rote, die nächsten 3 Bytes der IR-Messwert, jeweils eine 18-Bit-Zahl. Bei der Schlagerkennung wird der langsame Mittelwert (DC) vom IR-Signal abgezogen, sodass nur die Pulswelle (AC) bleibt; überschreitet die Welle 20 % der Fensteramplitude, zählt das als Schlag, und zwischen zwei Schlägen werden mindestens 300 ms abgewartet, was höchstens 200 BPM erlaubt. Da die SpO2 hier mit einer einfachen Spitze-Spitze-Methode berechnet wird, ist sie nur ein Näherungswert zu Lernzwecken.
Richtige Fingerlage und Bewegungsfehler
- Nimm die Fingerkuppe: Lege die weiche Spitze von Zeige- oder Mittelfinger so auf die LEDs, dass sie dem Fingernagel genau gegenüberliegt.
- Drücke leicht: Zu festes Drücken drängt das Blut aus den Kapillaren und die Welle wird kleiner; zu lockeres Halten lässt Umgebungslicht eindringen. Ein Gummiband oder ein Klettband mit gleichmäßigem, leichtem Druck liefert das beste Ergebnis.
- Schirme Umgebungslicht ab: Sonnenlicht und Leuchtstofflampen dringen in den Sensor ein und stören das Signal; eine dunkle Abdeckung über Finger und Sensor verbessert die Messung deutlich.
- Wärme den Finger auf: In einem kalten Finger fließt weniger Blut, das Signal wird schwächer. Schon ein paar Sekunden Händereiben vor der Messung machen einen Unterschied.
- Halte Kabel und Platine ruhig: Ein wackelndes Modul auf dem Breadboard bringt bei jeder Berührung Rauschen ins Signal; befestige den Sensor auf dem Tisch oder in einem Gehäuse.
- Sprechen und Bewegen: Wenn du während der Messung den Finger bewegst, sprichst oder den Arm hebst und senkst, entstehen viel größere Schwankungen als die Pulswelle selbst.
Bewegungsfehler sind das größte Problem bei MAX30102-Projekten. Die Pulswelle macht nur etwa 1–2 % des gesamten vom Sensor gemessenen Lichts aus; verrutscht der Finger um ein paar Millimeter, ist die Änderung viel größer, und der Algorithmus hält diese Schwankung für einen Schlag. Im Serial Monitor siehst du dann plötzlich unrealistische Werte wie 150 oder 40 BPM. Um das zu verringern, miss im Ruhezustand, mittle mehrere Ergebnisse und verwirf ungültige Ergebnisse (valid = 0), ohne sie anzuzeigen. In fortgeschrittenen Projekten kommen gleitende Mittelwerte, Medianfilter oder Bandpassfilter zum Einsatz; die Umsetzung dieser Techniken auf dem Arduino findest du im Beitrag Sensordaten filtern.
Projektideen mit dem MAX30102
- Pulsanzeige für den Schreibtisch: Zeige BPM und SpO2 auf einem SSD1306-OLED mit großen Ziffern und einer durchlaufenden Pulswelle an.
- Herzschlag-Ton: Spiele bei jedem Schlag mit einem Buzzer ein kurzes "Piep" ab und hole dir das Gefühl eines Apotheken-Oximeters.
- Erholungstest nach dem Sport: Miss deinen Puls direkt nach dem Training und eine Minute später und berechne die Differenz.
- Datenlogger: Schreibe die Messwerte mit Zeitstempel auf eine SD-Karte und stelle sie danach am Computer als Diagramm dar.
- ESP32-Benachrichtigung: Schicke das Ergebnis nach der Messung per Telegram-Bot als Nachricht aufs Handy.
- Vergleich für die Schülerwettbewerb-Ausstellung: Betreibe den analogen Pulssensor und den MAX30102 gleichzeitig und stelle in einer Tabelle gegenüber, welcher stabilere Werte liefert.
Häufige Fehler und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| "MAX30102 nicht gefunden" | SDA und SCL vertauscht, VIN nicht angeschlossen oder Pull-ups an 1,8 V | Kabel prüfen, mit I2C-Scanner nach 0x57 suchen, Lötbrücke auf 3,3 V setzen |
| IR-Wert immer unter 50.000 | Finger liegt nicht genau auf dem Sensor oder LED-Strom zu niedrig | Finger mittig auf die LEDs legen, ledBrightness erhöhen |
| Werte nahe 262.143 und ändern sich nicht | ADC ist gesättigt, Licht zu stark | ledBrightness senken oder adcRange auf 8192 oder 16384 setzen |
| BPM springt zwischen 40 und 180 | Bewegung, zu fester Druck oder Umgebungslicht | Finger fixieren, leicht drücken, Sensor vor Licht schützen |
| SpO2 dauerhaft "--" oder -999 | Algorithmus hält das Signal für ungültig (validSpo2 = 0) | 4 Sekunden lang nicht bewegen, Finger aufwärmen und mit Band fixieren |
| Code hängt oder verhält sich komisch auf dem Uno | Zu wenig RAM, weitere große Bibliotheken geladen | 16-Bit-Puffer beibehalten, Texte in F() setzen oder auf ESP32 wechseln |
Der MAX30102 ist ein toller Lernsensor, der zeigt, wie elegant man mit zweifarbigem Licht und einem cleveren Algorithmus unseren Körper auslesen kann; interpretiere die Messwerte nur nicht wie medizinische Ergebnisse, sondern wie Versuchsdaten. Wenn du das Auslesen von I2C-Sensoren, die Anzeige von Werten und das Speichern von Daten vertiefen willst, findest du in der BlueGrays-App Messprojekte wie DHT11, LDR, I2C-LCD, OLED-Wetteranzeige und Temperaturlogger mit Schaltplänen und fertigem Code, Schritt für Schritt erklärt.
Häufige Fragen
Wie genau ist der mit dem MAX30102 gemessene SpO2-Wert?
Da Hobbymodule nicht kalibriert sind, kann der SpO2-Wert im Vergleich zu einem zugelassenen Oximeter um einige Prozentpunkte abweichen; Bewegung und Umgebungslicht vergrößern den Unterschied noch. Die Ergebnisse dienen zum Experimentieren und Lernen und dürfen nicht für gesundheitliche Entscheidungen genutzt werden.
Funktioniert der MAX30102 mit 5 V?
Da auf gängigen MAX30102-Modulen ein Spannungsregler sitzt, kannst du den VIN-Pin mit 3,3 V oder 5 V versorgen. Bei manchen Platinen hängen die I2C-Pull-ups aber an 1,8 V, und ein 5-V-Uno erkennt den Sensor eventuell nicht; dann musst du die Lötbrücke auf der Platine auf die 3,3-V-Seite setzen.
Was ist der Unterschied zwischen MAX30100 und MAX30102?
Beide messen mit roter und IR-LED Puls und SpO2. Der MAX30102 ist der neuere Chip und bietet bis zu 18 Bit ADC-Auflösung, einen FIFO mit 32 Werten und geringeren Stromverbrauch. Beim MAX30100 liegt der ADC bei bis zu 16 Bit und der FIFO bei 16 Werten.
Warum meldet mein MAX30102 den Fehler "sensor not found"?
Die häufigsten Ursachen sind vertauschte SDA- und SCL-Kabel, ein fehlendes VIN oder GND und Pull-up-Widerstände, die an 1,8 V hängen. Lass einen I2C-Scanner laufen und prüfe, ob die Adresse 0x57 erscheint; wenn nicht, liegt das Problem nicht im Code, sondern in der Verkabelung.
Was sind normale Puls- und SpO2-Werte?
Bei Erwachsenen in Ruhe liegt der Puls meist zwischen 60 und 100 Schlägen pro Minute, bei Sportlern kann er niedriger sein. Die SpO2 liegt bei gesunden Menschen meist zwischen 95 % und 100 %. Siehst du mit deinem Hobbysensor Werte außerhalb dieses Bereichs, prüfe zuerst die Messbedingungen und wende dich bei echtem Verdacht an ein zugelassenes Gerät.
Kann der MAX30102 am Handgelenk oder Ohr messen?
Da der Sensor mit Reflexion arbeitet, kann er auch am Handgelenk oder Ohrläppchen eine Pulswelle erfassen, doch dort ist das Signal viel schwächer als an der Fingerspitze und empfindlich gegenüber Bewegung. Smartwatches nutzen deshalb stärkere LEDs, Bewegungskorrektur mit Beschleunigungssensor und anspruchsvollere Algorithmen.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

HC-SR04 Abstandsmessung (serielle Anzeige)
Der Sensor HC-SR04 funktioniert wie eine Fledermaus, die im Dunkeln ihren Weg findet: Er sendet einen Ton, den du nicht hörst, lauscht auf das Echo und misst, wie weit der Gegenstand vor ihm entfernt…

Lichtstärke messen mit LDR
Willst du sehen, wie hell dein Zimmer ist, und zwar als Zahl? Der LDR, ein kleines lichtempfindliches Bauteil, misst das Umgebungslicht, und der Arduino schreibt den Wert jede halbe Sekunde auf…

Verwendung des LCD-Bildschirms mit I2C
Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

ESP32 I2C-LCD-Display (16×2)
In diesem Projekt schließen wir ein 16x2-Zeichen-LCD über I2C an den ESP32 an und zeigen Text an. Dank I2C reichen 2 Datenpins (SDA und SCL) statt der 6+ Pins einer klassischen Parallelverbindung. Der Code schreibt eine feste Nachricht in die erste Zeile und einen sekündlich steigenden Zähler in die zweite. Beim Start gibt ein I2C-Scanner die Adresse des Displays im Serial Monitor aus (meist 0x27 oder 0x3F).

ESP32 HTTPClient + Wetter-API (mit SSD1306-OLED-Display)
Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Anders als die I2C-LCD-Version nutzt dieses Projekt ein SSD1306-OLED (128×64) mit großer Schrift und Vektor-Icons für eine reichere Darstellung. Sieben Wetter-Icons (sonnig, Regen, Schnee und mehr) werden ohne Bitmap-Dateien direkt gezeichnet.

ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
Im Deep-Sleep-Modus schaltet der ESP32 die CPU und die meisten Peripheriegeräte ab und senkt den Strom auf etwa 10µA, entscheidend für batteriebetriebene IoT-Geräte. Das Projekt nutzt drei Weckquellen: einen Timer (15 s), einen externen Pin (EXT0, Taster an GPIO 33) und einen Touch-Pin (T0/GPIO 4). Mit RTC_DATA_ATTR markierte Zähler bleiben im Deep Sleep erhalten.

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

