MAX30102 Arduino : mesurer le pouls et la SpO2, câblage et codes
Câblage du MAX30102 sur Arduino (I2C, 0x57), principe LED rouge et IR, lecture du pouls et de la SpO2 avec la bibliothèque SparkFun ; codes Uno, ESP32 et Pico.
Le MAX30102 est un petit capteur optique qui sert, dans les projets Arduino, à mesurer le pouls (fréquence cardiaque) et la saturation en oxygène du sang (SpO2) au bout du doigt. Une seule puce contient une LED rouge et une LED infrarouge (IR), une photodiode qui détecte la lumière, un CAN 18 bits et une mémoire FIFO qui stocke les mesures. Il communique avec l'Arduino par seulement deux fils de données, en I2C ; tu le branches donc en quelques minutes sur Uno, ESP32 et Raspberry Pi Pico. C'est exactement le principe des oxymètres de pouls vendus en pharmacie.
Dans cet article, tu vas voir comment le MAX30102 mesure le pouls et l'oxygène avec la lumière, les broches du module et le tableau de câblage par carte, la lecture du pouls avec la bibliothèque SparkFun sur Arduino Uno, le calcul simultané du pouls et de la SpO2 sur ESP32, puis le code MicroPython sans bibliothèque sur Pico. À la fin, tu sauras vaincre les deux plus grands ennemis des mesures : un mauvais placement du doigt et le mouvement.
Qu'est-ce que le MAX30102 et comment fonctionne-t-il ?
Le capteur envoie de la lumière rouge et infrarouge dans le bout du doigt ; la photodiode située juste à côté mesure la lumière renvoyée par les tissus. Comme les LED et le détecteur sont sur la même face, on parle de mesure par réflexion. À chaque battement, un peu plus de sang remplit les capillaires du doigt ; le sang absorbant la lumière, celle qui revient vers la photodiode diminue à cet instant. Le signal mesuré présente donc une petite onde qui monte et descend au rythme du cœur. Cette méthode s'appelle la photopléthysmographie (PPG). En mesurant le temps entre deux battements, tu obtiens le pouls : si les battements sont espacés de 0,8 seconde, le pouls vaut 60 / 0,8 = 75 BPM (battements par minute).
La mesure de l'oxygène repose sur le fait que les deux couleurs se comportent différemment dans le sang. L'hémoglobine oxygénée absorbe plus la lumière infrarouge et moins la rouge ; l'hémoglobine désoxygénée absorbe davantage la lumière rouge. Pour chaque couleur, le capteur calcule le rapport entre la variation du signal (AC) et son niveau constant (DC), puis divise ces deux rapports : R = (AC_rouge / DC_rouge) / (AC_IR / DC_IR). Plus R diminue, plus la SpO2 augmente. L'algorithme d'exemple de Maxim convertit R en pourcentage avec la formule approximative SpO2 = −45,060·R² + 30,354·R + 94,845 ; pour R = 0,5 on obtient environ 98,8 %, pour R = 1 environ 80 %. On voit qu'une petite erreur de mesure représente plusieurs points d'écart sur la SpO2.
| Caractéristique | Valeur |
|---|---|
| Fabricant | Maxim Integrated (aujourd'hui Analog Devices) |
| LED | Rouge 660 nm, infrarouge (IR) 880 nm |
| CAN | Jusqu'à 18 bits, 50 à 3200 échantillons/seconde |
| Mémoire | FIFO de 32 échantillons |
| Interface | I2C, adresse 0x57 (en notation 8 bits : écriture 0xAE, lecture 0xAF), jusqu'à 400 kHz |
| Alimentation de la puce | Cœur 1,8 V, LED 3,1 à 5 V |
| Alimentation du module | VIN 3,3 à 5 V (des régulateurs sont présents sur la carte) |
| Courant des LED | Réglable par logiciel de 0 à 50 mA (pas de 0,2 mA) |
| Courant en mode arrêt | Environ 0,7 µA |
| Fonction en plus | Capteur de température interne mesurant la température de la puce |
Différences entre le MAX30102, le MAX30100 et les capteurs de pouls analogiques
| Caractéristique | MAX30102 | MAX30100 | Pulse Sensor / KY-039 |
|---|---|---|---|
| Mesure | Pouls + SpO2 | Pouls + SpO2 | Pouls uniquement |
| Sortie | I2C (numérique) | I2C (numérique) | Tension analogique |
| Résolution du CAN | Jusqu'à 18 bits | Jusqu'à 16 bits | CAN du microcontrôleur |
| FIFO | 32 échantillons | 16 échantillons | Aucune |
| Source de lumière | Rouge + IR | Rouge + IR | LED verte ou LED IR |
| Complexité du code | Facile avec la bibliothèque | Facile avec la bibliothèque | Le plus simple avec analogRead |

Broches du MAX30102 et tableau de câblage
| Broche MAX30102 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN | 5V (ou 3.3V) | 3V3 | 3V3(OUT) (broche 36) |
| GND | GND | GND | GND |
| SCL | A5 | GPIO 22 | GP5 (broche 7) |
| SDA | A4 | GPIO 21 | GP4 (broche 6) |
| INT | Peut rester non connectée | Peut rester non connectée | Peut rester non connectée |
| IRD / RD | Laisse libre | Laisse libre | Laisse libre |
L'adresse I2C du capteur est fixe : 0x57. Si tu as un doute sur tes câbles, lance un scanner I2C et vérifie que cette adresse apparaît ; nous avons expliqué en détail le fonctionnement du bus I2C dans l'article Qu'est-ce que l'I2C ?. La broche INT est une sortie d'interruption qui passe à LOW quand de nouvelles données sont prêtes ; les codes de cet article interrogent le capteur en continu, cette broche est donc inutile. Les broches IRD et RD sont les sorties de pilotage des LED et restent libres en usage normal.
Installer la bibliothèque : SparkFun MAX3010x
- Dans l'IDE Arduino, ouvre le gestionnaire de bibliothèques et tape SparkFun MAX3010x.
- Installe la bibliothèque SparkFun MAX3010x Pulse and Proximity Sensor Library. Même si son nom contient MAX30105, elle fonctionne à l'identique avec le MAX30102 ; seule la LED verte manque sur le MAX30102.
- La bibliothèque apporte trois fichiers : MAX30105.h qui pilote le capteur, heartRate.h qui détecte les battements et spo2_algorithm.h qui contient l'algorithme SpO2 de Maxim.
- Si tu débutes avec les bibliothèques, jette un œil à l'article Ajouter une bibliothèque à Arduino.
Mesurer le pouls (BPM) avec 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}| Morceau de code | Ce qu'il fait |
|---|---|
| sensor.begin(Wire, I2C_SPEED_FAST) | Démarre le capteur en I2C à 400 kHz ; renvoie false s'il ne le trouve pas. |
| sensor.setup(0x1F, 4, 2, 400, 411, 4096) | Choisit un courant de LED d'environ 6,2 mA, une moyenne sur 4 échantillons, le mode rouge + IR, 400 échantillons/s, une impulsion de 411 µs et une plage de CAN de 4096 nA. |
| sensor.getIR() | Renvoie la dernière mesure infrarouge ; avec un doigt en place, elle dépasse généralement 50 000. |
| checkForBeat(ir) | Renvoie true à chaque pic de battement détecté dans le signal. |
| 60.0 / (delta / 1000.0) | Convertit les millisecondes entre deux battements en nombre de battements par minute. |
| Tableau rates[] | Lisse les valeurs instables en faisant la moyenne des 4 dernières mesures. |
Lire le pouls et la SpO2 ensemble (ESP32 et Uno)
Pour mesurer l'oxygène, il ne suffit pas de compter les pics ; il faut un enregistrement de quelques secondes des signaux rouge et IR. Le code ci-dessous est réglé pour prendre 25 échantillons par seconde (mesure à 100 Hz, moyenne sur 4) et remplit une fenêtre de 100 échantillons, soit 4 secondes. L'algorithme de Maxim calcule ensuite le pouls et la SpO2 à partir de cette fenêtre. Aux tours suivants, les 25 échantillons les plus anciens sont éliminés et 25 nouveaux sont ajoutés ; tu obtiens ainsi un nouveau résultat chaque seconde. Comme les 2 Ko de RAM de l'Uno sont trop justes pour deux tableaux de 32 bits, le code passe automatiquement à des tableaux de 16 bits sur Uno ; l'exemple officiel de SparkFun fait de même.
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}| Paramètre de setup() | Valeur dans ce code | Options |
|---|---|---|
| ledBrightness | 60 (environ 12 mA) | 0 = éteint … 255 = 50 mA |
| sampleAverage | 4 | 1, 2, 4, 8, 16, 32 |
| ledMode | 2 (rouge + IR) | 1 = rouge seul, 2 = rouge + IR, 3 = vert aussi (MAX30105 uniquement) |
| sampleRate | 100 | 50, 100, 200, 400, 800, 1000, 1600, 3200 |
| pulseWidth | 411 µs (18 bits) | 69, 118, 215, 411 µs |
| adcRange | 4096 nA | 2048, 4096, 8192, 16384 |
MAX30102 avec l'ESP32
Le code SpO2 ci-dessus fonctionne sur ESP32 sans aucune modification ; les broches I2C par défaut sont GPIO 21 (SDA) et GPIO 22 (SCL), et comme le code n'utilise que la bibliothèque Wire, il compile de la même façon avec les versions 2.x et 3.x du noyau Arduino ESP32. Alimente impérativement le module par la broche 3V3 pour que les lignes I2C restent à 3,3 V. La RAM abondante de l'ESP32 accueille sans souci les tampons 32 bits, et son second cœur ainsi que le Wi-Fi facilitent l'envoi des mesures vers un téléphone ou internet. Tu peux par exemple afficher les résultats sur un écran OLED, les envoyer au téléphone en Bluetooth BLE ou mesurer à intervalles courts et passer en veille profonde entre deux mesures pour prolonger l'autonomie de la batterie. L'OLED et le capteur peuvent partager la même ligne I2C ; leurs adresses étant différentes (0x3C et 0x57), il n'y a pas de conflit.
Raspberry Pi Pico et MicroPython avec le MAX30102
Il n'existe pas de pilote MAX30102 officiel prêt à l'emploi pour MicroPython ; mais comme les registres du capteur sont simples, tu peux le gérer toi-même en quelques lignes. Le code ci-dessous met le capteur en mode SpO2, lit les échantillons rouge et IR dans la FIFO, détecte les battements sur le signal IR, calcule le rapport R sur une fenêtre de 4 secondes et affiche une SpO2 approximative. Si tu débutes avec le Pico et MicroPython, regarde d'abord les articles Qu'est-ce que le Raspberry Pi Pico ? et Bases de MicroPython.
1from machine import Pin, I2C
2import time
3
4ADDR = 0x57 # MAX30102 I2C adresi / I2C address
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
6
7def wr(reg, val):
8 i2c.writeto_mem(ADDR, reg, bytes([val]))
9
10def rd(reg, n=1):
11 return i2c.readfrom_mem(ADDR, reg, n)
12
13if rd(0xFF)[0] != 0x15: # PART_ID kontrolü / PART_ID check
14 raise RuntimeError("MAX30102 bulunamadi / not found")
15
16wr(0x09, 0x40) # yazılımla sıfırla / software reset
17time.sleep_ms(100)
18wr(0x08, 0x5F) # 4 örnek ortalama + FIFO rollover / 4-sample average + rollover
19wr(0x09, 0x03) # SpO2 modu: kırmızı + IR / SpO2 mode: red + IR
20wr(0x0A, 0x27) # 4096 nA, 100 Hz, 411 us (18 bit)
21wr(0x0C, 0x24) # kırmızı LED ~7,2 mA / red LED ~7.2 mA
22wr(0x0D, 0x24) # IR LED ~7,2 mA / IR LED ~7.2 mA
23for reg in (0x04, 0x05, 0x06): # FIFO işaretçilerini sıfırla / reset FIFO pointers
24 wr(reg, 0)
25
26def read_fifo():
27 n = (rd(0x04)[0] - rd(0x06)[0]) & 0x1F # bekleyen örnek / pending samples
28 out = []
29 if n:
30 d = rd(0x07, 6 * n) # her örnek 6 bayt / 6 bytes per sample
31 for i in range(n):
32 k = 6 * i
33 red = ((d[k] << 16) | (d[k + 1] << 8) | d[k + 2]) & 0x3FFFF
34 ir = ((d[k + 3] << 16) | (d[k + 4] << 8) | d[k + 5]) & 0x3FFFF
35 out.append((red, ir))
36 return out
37
38FS = 25 # 100 Hz / 4 ortalama = 25 örnek/s / effective sample rate
39WIN = 100 # 4 saniyelik pencere / 4 second window
40reds, irs, beats = [], [], []
41dc = 0.0
42above = False
43count = 0
44last_beat = 0
45
46while True:
47 for red, ir in read_fifo():
48 count += 1
49 if ir < 50000: # parmak yok / no finger
50 reds, irs, beats = [], [], []
51 dc = 0.0
52 last_beat = 0
53 if count % FS == 0:
54 print("Parmak yok / No finger")
55 continue
56 if dc == 0.0:
57 dc = ir
58 dc += 0.05 * (ir - dc) # yavaş ortalama = DC / slow average = DC
59 ac = dc - ir # kan dolunca ışık azalır / light drops as blood fills
60 reds.append(red)
61 irs.append(ir)
62 if len(irs) > WIN:
63 reds.pop(0)
64 irs.pop(0)
65 thr = (max(irs) - min(irs)) * 0.2 # uyarlanır eşik / adaptive threshold
66 if not above and ac > thr and count - last_beat > FS * 0.3:
67 above = True
68 if last_beat:
69 bpm = 60 * FS / (count - last_beat)
70 if 40 <= bpm <= 200:
71 beats.append(bpm)
72 if len(beats) > 4:
73 beats.pop(0)
74 last_beat = count
75 elif ac < 0:
76 above = False
77 if count % FS == 0 and len(irs) == WIN and beats:
78 ac_r = max(reds) - min(reds)
79 ac_i = max(irs) - min(irs)
80 if ac_i > 0:
81 R = (ac_r / (sum(reds) / WIN)) / (ac_i / (sum(irs) / WIN))
82 spo2 = min(100, -45.060 * R * R + 30.354 * R + 94.845)
83 print("BPM: %d SpO2: %d %%" % (int(sum(beats) / len(beats)), int(spo2)))
84 time.sleep_ms(20)Le code vérifie d'abord que le registre PART_ID vaut 0x15 ; cette valeur indique que le capteur est bien un MAX30102. La valeur 0x27 écrite dans le registre 0x0A regroupe en un seul octet la plage de CAN de 4096 nA, la fréquence d'échantillonnage de 100 Hz et la largeur d'impulsion de 411 µs. En mode SpO2, chaque échantillon de la FIFO fait 6 octets : les 3 premiers sont la mesure rouge, les 3 suivants la mesure IR, chacune étant un nombre de 18 bits. Pour détecter les battements, on retire la moyenne lente (DC) du signal IR pour ne garder que l'onde du pouls (AC) ; un battement est compté quand l'onde dépasse 20 % de l'amplitude de la fenêtre, avec au moins 300 ms entre deux battements, ce qui autorise 200 BPM au maximum. Ici la SpO2 est calculée par une simple méthode crête à crête : ce n'est donc qu'une valeur approximative à but pédagogique.
Bon placement du doigt et erreur de mouvement
- Utilise le bout du doigt : pose la partie charnue de l'index ou du majeur sur les LED, juste en face de l'ongle.
- Appuie légèrement : appuyer trop fort chasse le sang des capillaires et l'onde diminue ; tenir trop lâche laisse entrer la lumière ambiante. Un élastique ou une sangle velcro qui donne une pression stable et légère offre le meilleur résultat.
- Coupe la lumière ambiante : le soleil et les lampes fluorescentes s'infiltrent dans le capteur et faussent le signal ; recouvrir le doigt et le capteur d'une gaine sombre améliore nettement la mesure.
- Réchauffe ton doigt : un doigt froid reçoit moins de sang et le signal faiblit. Frotter tes mains quelques secondes avant la mesure suffit déjà à faire la différence.
- Câbles et carte bien fixes : un module qui bouge sur la breadboard ajoute du bruit au signal à chaque contact ; fixe le capteur sur la table ou dans un boîtier.
- Parler et bouger : bouger le doigt, parler ou lever et baisser le bras pendant la mesure crée une fluctuation bien plus grande que l'onde du pouls.
L'erreur de mouvement est le plus gros problème des projets MAX30102. L'onde du pouls ne représente qu'environ 1 à 2 % de la lumière totale mesurée par le capteur ; un décalage du doigt de quelques millimètres provoque un changement bien plus grand, et l'algorithme prend cette fluctuation pour un battement. Résultat : tu vois soudain des valeurs irréalistes comme 150 ou 40 BPM dans le moniteur série. Pour réduire ce problème, mesure en restant immobile, fais la moyenne de plusieurs résultats et écarte sans les afficher les résultats invalides (valid = 0). Les projets plus avancés utilisent des moyennes mobiles, des médianes ou des filtres passe-bande ; tu trouveras leurs équivalents sur Arduino dans l'article filtrage des données de capteur.
Idées de projets avec le MAX30102
- Afficheur de pouls de bureau : affiche le BPM et la SpO2 en gros chiffres avec une onde de pouls défilante sur un écran OLED SSD1306.
- Son de battement : joue un court « bip » avec un buzzer à chaque battement, pour retrouver la sensation de l'oxymètre de pharmacie.
- Test de récupération après le sport : mesure ton pouls juste après l'effort puis 1 minute plus tard, et calcule la différence.
- Enregistreur de données : écris les mesures avec l'heure sur une carte SD, puis trace-les sur ordinateur.
- Système de notification ESP32 : quand la mesure est terminée, envoie le résultat en message sur ton téléphone avec un bot Telegram.
- Comparaison pour un salon scientifique : fais fonctionner en même temps un capteur de pouls analogique et le MAX30102, puis compare dans un tableau lequel donne les résultats les plus stables.
Erreurs fréquentes et solutions
| Symptôme | Cause possible | Solution |
|---|---|---|
| « MAX30102 introuvable » | SDA et SCL inversés, VIN non connecté ou pull-up à 1,8 V | Vérifie les câbles, cherche 0x57 avec un scanner I2C, bascule le pont de soudure sur 3,3 V |
| La valeur IR reste toujours sous 50 000 | Le doigt n'est pas pile sur le capteur ou le courant des LED est trop faible | Centre le doigt sur les LED, augmente ledBrightness |
| Les valeurs sont proches de 262 143 et ne changent pas | Le CAN est saturé, la lumière est trop forte | Baisse ledBrightness ou mets adcRange à 8192 ou 16384 |
| Le BPM saute entre 40 et 180 | Mouvement, pression trop forte ou lumière ambiante | Immobilise le doigt, appuie légèrement, protège le capteur de la lumière |
| La SpO2 reste « -- » ou -999 | L'algorithme juge le signal invalide (validSpo2 = 0) | Ne bouge pas pendant 4 secondes, réchauffe ton doigt et fixe-le avec une sangle |
| Sur Uno, le code se fige ou se comporte bizarrement | RAM insuffisante, d'autres grosses bibliothèques sont chargées | Garde les tampons 16 bits, mets les textes dans F() ou passe à l'ESP32 |
Le MAX30102 est un excellent capteur d'apprentissage, qui montre avec quelle élégance on peut lire le corps humain grâce à une lumière à deux couleurs et un algorithme malin ; il suffit d'interpréter les mesures comme des données d'expérience et non comme des résultats médicaux. Si tu veux consolider la lecture de capteurs en I2C, l'affichage des valeurs et l'enregistrement des données, tu peux découvrir dans l'application BlueGrays, pas à pas, des projets de mesure comme DHT11, LDR, LCD I2C, station météo OLED et enregistreur de température, avec schémas de câblage et codes prêts à l'emploi.
Questions fréquentes
Quelle est la précision de la SpO2 mesurée avec le MAX30102 ?
Les modules de loisir n'étant pas calibrés, la SpO2 peut s'écarter de plusieurs points par rapport à un oxymètre homologué ; le mouvement et la lumière ambiante amplifient encore cet écart. Les résultats sont destinés à l'expérimentation et à l'apprentissage, et ne doivent pas servir à des décisions de santé.
Le MAX30102 fonctionne-t-il en 5 V ?
Comme les modules MAX30102 courants ont un régulateur, la broche VIN peut être alimentée en 3,3 V ou en 5 V. Mais sur certaines cartes les pull-up I2C sont reliés à 1,8 V et un Uno en 5 V peut ne pas voir le capteur ; il faut alors basculer le pont de soudure de la carte côté 3,3 V.
Quelle est la différence entre le MAX30100 et le MAX30102 ?
Les deux mesurent le pouls et la SpO2 avec une LED rouge et une LED IR. Le MAX30102 est la puce plus récente : résolution de CAN jusqu'à 18 bits, FIFO de 32 échantillons et consommation plus faible. Sur le MAX30100, le CAN monte jusqu'à 16 bits et la FIFO est de 16 échantillons.
Pourquoi mon MAX30102 affiche-t-il l'erreur « sensor not found » ?
Les causes les plus fréquentes sont SDA et SCL inversés, un VIN ou un GND manquant et des pull-up reliés à 1,8 V. Lance un scanner I2C et regarde si l'adresse 0x57 apparaît ; si elle n'apparaît pas, le problème vient du câblage et non du code.
Quelles sont les valeurs normales de pouls et de SpO2 ?
Chez l'adulte au repos, le pouls se situe généralement entre 60 et 100 battements par minute, et peut être plus bas chez les sportifs. Chez les personnes en bonne santé, la SpO2 est généralement comprise entre 95 % et 100 %. Si ton capteur de loisir affiche une valeur hors de cette plage, vérifie d'abord les conditions de mesure ; en cas de vrai doute, adresse-toi à un appareil homologué.
Le MAX30102 peut-il mesurer au poignet ou à l'oreille ?
Comme le capteur fonctionne par réflexion, il peut capter l'onde du pouls au poignet ou au lobe de l'oreille, mais à ces endroits le signal est bien plus faible qu'au bout du doigt et sensible au mouvement. C'est pourquoi les montres connectées utilisent des LED plus puissantes, une correction de mouvement assistée par accéléromètre et des algorithmes avancés.
Projets à réaliser après cet article
Voir tous les projets
Température et humidité avec DHT11
Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

HC-SR04 Mesure de la distance (affichage en série)
Le capteur HC-SR04 fonctionne comme une chauve-souris qui trouve son chemin dans le noir : il envoie un son que tu ne peux pas entendre, écoute l'écho et mesure à quelle distance se trouve l'objet…

Mesurer l'intensité lumineuse avec une LDR
Envie de voir en chiffres à quel point ta chambre est lumineuse ? Le LDR, une petite pièce sensible à la lumière, mesure la lumière ambiante, et l'Arduino écrit la valeur sur l'écran de ton…

Utilisation de l'écran LCD avec I2C
Offre un écran à ton Arduino et fais-lui écrire son premier message. L'écran LCD à deux lignes se branche avec seulement quelques fils ; un bonjour s'affiche sur la ligne du haut, puis un deuxième…

Écran LCD I2C ESP32 (16x2)
Dans ce projet, on relie un écran LCD 16x2 caractères à l'ESP32 en I2C pour afficher du texte. Grâce à l'I2C, 2 broches de données (SDA et SCL) suffisent, au lieu des 6+ broches d'un branchement parallèle classique. Le code affiche un message fixe sur la première ligne et un compteur qui augmente chaque seconde sur la deuxième. Au démarrage, un scanner I2C écrit l'adresse de l'écran dans le Serial Monitor (souvent 0x27 ou 0x3F).

ESP32 HTTPClient + API météo (avec écran OLED SSD1306)
L'ESP32 appelle par Internet une API météo (wttr.in) en REST avec HTTPClient.h. Contrairement à la version LCD I2C, on utilise ici un écran OLED SSD1306 (128×64), avec un grand texte et des icônes vectorielles pour un affichage plus riche. Sept icônes météo (soleil, pluie, neige et plus) sont dessinées à la volée, sans fichier bitmap.

Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
Le mode Deep Sleep de l'ESP32 coupe le CPU et la plupart des périphériques et réduit la consommation à environ 10µA, un point clé pour les objets IoT sur batterie. Ce projet utilise trois sources de réveil : un minuteur (15 s), une broche externe (EXT0, le bouton sur GPIO 33) et une broche tactile (T0/GPIO 4). Les compteurs marqués RTC_DATA_ATTR sont conservés pendant le deep sleep.

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

