MAX30102 com Arduino: ligação e código do sensor de frequência cardíaca e SpO2
Como usar o MAX30102 com Arduino? Ligação I2C (0x57), como a luz vermelha e a IR medem pulso e SpO2, biblioteca SparkFun e código para Uno, ESP32 e Pico.
O MAX30102 é um pequeno sensor óptico usado em projetos com Arduino para medir o pulso (frequência cardíaca) e a saturação de oxigênio no sangue (SpO2) pela ponta do dedo. Um único chip contém um LED vermelho e um infravermelho (IR), um fotodiodo que detecta a luz, um ADC de 18 bits e uma memória (FIFO) que guarda as leituras. Ele se comunica com o Arduino por apenas dois fios de dados, via I2C, então você consegue ligá-lo a um Uno, ESP32 ou Raspberry Pi Pico em poucos minutos. Os oxímetros de dedo vendidos em farmácias funcionam exatamente com esse princípio.
Neste post você vai ver, passo a passo, como o MAX30102 mede pulso e oxigênio com luz, os pinos do módulo e uma tabela de ligação para cada placa, como ler o pulso num Arduino Uno com a biblioteca SparkFun, como calcular pulso e SpO2 juntos num ESP32 e um código em MicroPython sem biblioteca para o Pico. No final, você vai aprender a vencer os dois maiores inimigos de boas leituras: o dedo mal posicionado e o movimento.
O que é o MAX30102 e como ele funciona?
O sensor envia luz vermelha e infravermelha para a ponta do dedo, e o fotodiodo, logo ao lado dos LEDs, mede a luz refletida de volta pelo tecido. Como os LEDs e o detector ficam na mesma face, isso se chama medição por reflexão. A cada batimento, um pouco mais de sangue enche os capilares do dedo; como o sangue absorve luz, a luz que volta ao fotodiodo diminui nesse momento. Isso gera no sinal medido uma pequena onda que sobe e desce no mesmo ritmo do coração. Esse método se chama fotopletismografia (PPG). Medindo o tempo entre dois batimentos, você obtém o pulso: se os batimentos chegam com 0,8 segundo de intervalo, o pulso é 60 / 0,8 = 75 BPM (batimentos por minuto).
Já a medição de oxigênio se baseia no comportamento diferente das duas cores no sangue. A hemoglobina que carrega oxigênio absorve mais luz infravermelha e menos luz vermelha, enquanto a hemoglobina que liberou o oxigênio absorve mais luz vermelha. Para cada cor, o sensor calcula a razão entre a oscilação do sinal (AC) e seu nível constante (DC) e divide uma razão pela outra: R = (AC_vermelho / DC_vermelho) / (AC_IR / DC_IR). Quanto menor o R, maior o SpO2. O algoritmo de exemplo da Maxim converte R em porcentagem com aproximadamente SpO2 = −45,060·R² + 30,354·R + 94,845; R = 0,5 dá cerca de 98,8%, enquanto R = 1 dá cerca de 80%. Como dá para ver, um pequeno erro de medição significa um desvio de vários pontos no SpO2.
| Característica | Valor |
|---|---|
| Fabricante | Maxim Integrated (hoje Analog Devices) |
| LEDs | Vermelho 660 nm, infravermelho (IR) 880 nm |
| ADC | Resolução de até 18 bits, 50–3200 amostras/segundo |
| Memória | FIFO de 32 amostras |
| Interface | I2C, endereço 0x57 (em notação de 8 bits: escrita 0xAE, leitura 0xAF), até 400 kHz |
| Alimentação do chip | Núcleo 1,8 V, LEDs 3,1–5 V |
| Alimentação do módulo | VIN 3,3–5 V (a placa tem reguladores) |
| Corrente dos LEDs | Ajustável por software de 0 a 50 mA (em passos de 0,2 mA) |
| Corrente em modo desligado | Cerca de 0,7 µA |
| Recurso extra | Sensor de temperatura interno que mede a temperatura do chip |
MAX30102, MAX30100 e sensores de pulso analógicos: diferenças
| Característica | MAX30102 | MAX30100 | Pulse Sensor / KY-039 |
|---|---|---|---|
| O que mede | Pulso + SpO2 | Pulso + SpO2 | Só o pulso |
| Saída | I2C (digital) | I2C (digital) | Tensão analógica |
| Resolução do ADC | Até 18 bits | Até 16 bits | O ADC do microcontrolador |
| FIFO | 32 amostras | 16 amostras | Não tem |
| Fonte de luz | Vermelho + IR | Vermelho + IR | LED verde ou LED IR |
| Complexidade do código | Fácil com biblioteca | Fácil com biblioteca | O mais simples, com analogRead |

Pinos do MAX30102 e tabela de ligação
| Pino do MAX30102 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN | 5V (ou 3.3V) | 3V3 | 3V3(OUT) (pino 36) |
| GND | GND | GND | GND |
| SCL | A5 | GPIO 22 | GP5 (pino 7) |
| SDA | A4 | GPIO 21 | GP4 (pino 6) |
| INT | Opcional | Opcional | Opcional |
| IRD / RD | Deixe livre | Deixe livre | Deixe livre |
O endereço I2C do sensor é fixo: 0x57. Se não tiver certeza da ligação, você pode rodar um sketch scanner I2C e conferir se esse endereço aparece na lista; explicamos em detalhes como funciona o barramento I2C em O que é I2C?. O pino INT é uma saída de interrupção que vai para LOW quando há dados novos prontos; como o código deste post consulta o sensor continuamente, você não precisa desse pino. Os pinos IRD e RD são os terminais de acionamento dos LEDs e ficam desconectados no uso normal.
Instalando a biblioteca: SparkFun MAX3010x
- Abra o Gerenciador de Bibliotecas na Arduino IDE e digite SparkFun MAX3010x.
- Instale a SparkFun MAX3010x Pulse and Proximity Sensor Library. Mesmo com MAX30105 no nome, ela funciona igualzinho com o MAX30102; o MAX30102 só não tem o LED verde.
- A biblioteca traz três arquivos: MAX30105.h, que controla o sensor, heartRate.h, que detecta os batimentos, e spo2_algorithm.h, que contém o algoritmo de SpO2 da Maxim.
- Se você nunca instalou uma biblioteca, dê uma olhada em Como instalar biblioteca no Arduino.
Medindo o pulso (BPM) com 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}| Trecho de código | O que faz |
|---|---|
| sensor.begin(Wire, I2C_SPEED_FAST) (inicialização) | Inicia o sensor com I2C a 400 kHz; retorna false se não o encontrar. |
| sensor.setup(0x1F, 4, 2, 400, 411, 4096) (configuração) | Seleciona corrente dos LEDs de cerca de 6,2 mA, média de 4 amostras, modo vermelho + IR, 400 amostras/s, largura de pulso de 411 µs e faixa do ADC de 4096 nA. |
| sensor.getIR() (leitura IR) | Retorna a última leitura infravermelha; com o dedo no sensor, normalmente fica acima de 50.000. |
| checkForBeat(ir) (detecção de batimento) | Retorna true sempre que detecta um pico de batimento no sinal. |
| 60.0 / (delta / 1000.0) (cálculo do BPM) | Converte os milissegundos entre dois batimentos em batimentos por minuto. |
| Array rates[] | Suaviza valores que pulam fazendo a média das últimas 4 leituras. |
Lendo pulso e SpO2 juntos (ESP32 e Uno)
Para medir oxigênio, não basta contar picos; é preciso registrar alguns segundos dos sinais vermelho e IR. O código abaixo está configurado para pegar 25 amostras por segundo (medição a 100 Hz, média de 4×) e preenche uma janela de 100 amostras, ou seja, 4 segundos. Em seguida, o algoritmo da Maxim calcula o pulso e o SpO2 a partir dessa janela. A cada rodada seguinte, as 25 amostras mais antigas são descartadas e 25 novas são adicionadas, então você recebe um resultado novo a cada segundo. Como os 2 KB de RAM do Uno são apertados para dois arrays de 32 bits, o código muda automaticamente para arrays de 16 bits no Uno; o exemplo oficial da SparkFun faz o mesmo.
1#include <Wire.h>
2#include "MAX30105.h"
3#include "spo2_algorithm.h"
4
5MAX30105 sensor;
6
7#if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)
8uint16_t irBuffer[100]; // Uno'da RAM yetmediği için 16 bit / 16-bit on Uno to save RAM
9uint16_t redBuffer[100];
10#else
11uint32_t irBuffer[100]; // ESP32'de tam 32 bit / full 32-bit on ESP32
12uint32_t redBuffer[100];
13#endif
14
15const int32_t BUFFER_LENGTH = 100; // 25 örnek/s x 4 s / 25 samples/s x 4 s
16int32_t spo2;
17int8_t validSpo2;
18int32_t heartRate;
19int8_t validHeartRate;
20bool firstFill = true;
21
22void readSample(int i) {
23 while (!sensor.available()) sensor.check(); // yeni örnek bekle / wait for a new sample
24 redBuffer[i] = sensor.getRed();
25 irBuffer[i] = sensor.getIR();
26 sensor.nextSample();
27}
28
29void setup() {
30 Serial.begin(115200);
31#if defined(ESP32)
32 Wire.begin(21, 22); // SDA, SCL
33#endif
34 if (!sensor.begin(Wire, I2C_SPEED_FAST)) {
35 Serial.println(F("MAX30102 bulunamadi / not found"));
36 while (1);
37 }
38 // parlaklık 60 (~12 mA), 4 ortalama, kırmızı + IR, 100 Hz, 411 us, 4096 nA
39 // brightness 60 (~12 mA), average 4, red + IR, 100 Hz, 411 us, 4096 nA
40 sensor.setup(60, 4, 2, 100, 411, 4096);
41}
42
43void loop() {
44 if (firstFill) { // ilk 4 saniyeyi doldur / fill the first 4 seconds
45 for (int i = 0; i < BUFFER_LENGTH; i++) readSample(i);
46 firstFill = false;
47 } else { // 25 örnek kaydır, 25 yeni oku / shift 25, read 25 new
48 for (int i = 25; i < BUFFER_LENGTH; i++) {
49 redBuffer[i - 25] = redBuffer[i];
50 irBuffer[i - 25] = irBuffer[i];
51 }
52 for (int i = 75; i < BUFFER_LENGTH; i++) readSample(i);
53 }
54
55 maxim_heart_rate_and_oxygen_saturation(irBuffer, BUFFER_LENGTH, redBuffer,
56 &spo2, &validSpo2, &heartRate, &validHeartRate);
57
58 Serial.print(F("Nabiz / HR: "));
59 if (validHeartRate) Serial.print(heartRate); else Serial.print(F("--"));
60 Serial.print(F(" BPM SpO2: "));
61 if (validSpo2) Serial.print(spo2); else Serial.print(F("--"));
62 Serial.println(F(" %"));
63}| Parâmetro de setup() | Valor neste código | Opções |
|---|---|---|
| ledBrightness (brilho dos LEDs) | 60 (cerca de 12 mA) | 0 = desligado … 255 = 50 mA |
| sampleAverage (média de amostras) | 4 | 1, 2, 4, 8, 16, 32 |
| ledMode (modo dos LEDs) | 2 (vermelho + IR) | 1 = só vermelho, 2 = vermelho + IR, 3 = verde também (só MAX30105) |
| sampleRate (taxa de amostragem) | 100 | 50, 100, 200, 400, 800, 1000, 1600, 3200 |
| pulseWidth (largura de pulso) | 411 µs (18 bits) | 69, 118, 215, 411 µs |
| adcRange (faixa do ADC) | 4096 nA | 2048, 4096, 8192, 16384 |
MAX30102 com o ESP32
O código de SpO2 acima roda no ESP32 sem nenhuma alteração; os pinos I2C padrão são GPIO 21 (SDA) e GPIO 22 (SCL) e, como o código usa só a biblioteca Wire, ele compila do mesmo jeito nas versões 2.x e 3.x do core do ESP32 para Arduino. Sempre alimente o módulo pelo pino 3V3, para que as linhas I2C fiquem em 3,3 V. A RAM farta do ESP32 acomoda tranquilamente buffers de 32 bits, e o segundo núcleo e o Wi-Fi facilitam enviar as medições para o celular ou para a internet. Por exemplo, você pode mostrar os resultados num display OLED de 0,96 polegada, enviá-los para o celular via Bluetooth BLE ou medir em intervalos curtos e entrar em deep sleep entre uma medição e outra para aumentar a autonomia da bateria. O OLED e o sensor podem compartilhar o mesmo barramento I2C; os endereços são diferentes (0x3C e 0x57), então não há conflito.
MAX30102 com Raspberry Pi Pico e MicroPython
Não existe um driver oficial e pronto do MAX30102 para MicroPython, mas, como os registradores do sensor são simples, você mesmo consegue controlá-lo com poucas linhas. O código abaixo coloca o sensor no modo SpO2, lê as amostras vermelha e IR da FIFO, detecta os batimentos no sinal IR e calcula a razão R a partir de uma janela de 4 segundos para mostrar um valor aproximado de SpO2. Se você é novo no Pico e no MicroPython, veja primeiro O que é o Raspberry Pi Pico? e fundamentos 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)Primeiro, o código confere se o registrador PART_ID vale 0x15; esse valor mostra que o sensor é mesmo um MAX30102. O 0x27 escrito no registrador 0x0A reúne num único byte a faixa do ADC de 4096 nA, a taxa de amostragem de 100 Hz e a largura de pulso de 411 µs. No modo SpO2, cada amostra na FIFO tem 6 bytes: os 3 primeiros são a leitura do vermelho, os 3 seguintes a do IR, e cada uma é um número de 18 bits. Para detectar os batimentos, a média lenta (DC) do sinal IR é subtraída, deixando só a onda de pulso (AC); um batimento é contado quando a onda passa de 20% da amplitude da janela, e precisam passar pelo menos 300 ms entre dois batimentos, o que permite no máximo 200 BPM. Como aqui o SpO2 é calculado por um método simples de pico a pico, ele é apenas um valor aproximado, para fins educativos.
Posição correta do dedo e erro por movimento
- Use a ponta do dedo: coloque a parte macia da ponta do indicador ou do dedo médio sobre os LEDs, bem do lado oposto à unha.
- Pressione de leve: apertar demais expulsa o sangue dos capilares e a onda fica menor; segurar frouxo demais deixa a luz ambiente entrar. Uma pressão leve e constante com um elástico ou uma tira de velcro dá o resultado ideal.
- Bloqueie a luz ambiente: a luz do sol e as lâmpadas fluorescentes vazam para o sensor e estragam o sinal; cobrir o dedo e o sensor com uma capa escura melhora a medição de forma visível.
- Aqueça o dedo: num dedo frio o fluxo de sangue diminui e o sinal enfraquece. Esfregar as mãos por alguns segundos antes de medir já faz diferença.
- Deixe fios e placa firmes: um módulo balançando na protoboard adiciona ruído ao sinal a cada toque; fixe o sensor na mesa ou numa caixa.
- Falar e se mexer: mexer o dedo, falar ou levantar e abaixar o braço durante a medição gera oscilações muito maiores que a onda de pulso.
O erro por movimento é o maior problema dos projetos com MAX30102. A onda de pulso é só cerca de 1–2% da luz total que o sensor mede; um dedo que escorrega alguns milímetros causa uma variação muito maior, e o algoritmo confunde essa oscilação com um batimento. Resultado: de repente aparecem no Monitor Serial valores irreais, como 150 ou 40 BPM. Para reduzir isso, meça parado, faça a média de vários resultados e descarte os resultados inválidos (valid = 0) em vez de mostrá-los. Projetos mais avançados usam filtros de média móvel, mediana ou passa-faixa; você encontra os equivalentes no Arduino no post filtragem de dados de sensores.
Ideias de projetos com o MAX30102
- Indicador de pulso de mesa: mostre BPM e SpO2 em números grandes, com uma onda de pulso rolando, num display OLED SSD1306 de 0,96 polegada.
- Som do batimento: toque um “bip” curto num buzzer a cada batimento, com cara de oxímetro de farmácia.
- Teste de recuperação pós-treino: meça o pulso logo depois do exercício e 1 minuto depois, e calcule a diferença.
- Datalogger: grave as leituras com data e hora num cartão SD e depois faça o gráfico no computador.
- Sistema de notificação com ESP32: quando a medição terminar, envie o resultado como mensagem para o seu celular por um bot do Telegram.
- Comparação para feira de ciências: rode um sensor de pulso analógico e o MAX30102 ao mesmo tempo e monte uma tabela mostrando qual dá resultados mais estáveis.
Erros comuns e como resolver
| Sintoma | Causa provável | Solução |
|---|---|---|
| “MAX30102 not found” (sensor não encontrado) | SDA e SCL invertidos, VIN não ligado ou pull-ups em 1,8 V | Confira os fios, procure 0x57 com um scanner I2C, passe o jumper de solda para 3,3 V |
| Valor IR sempre abaixo de 50.000 | O dedo não está bem em cima do sensor ou a corrente dos LEDs está baixa demais | Centralize o dedo sobre os LEDs, aumente ledBrightness |
| Valores perto de 262.143 que nunca mudam | O ADC saturou, a luz está forte demais | Diminua ledBrightness ou ajuste adcRange para 8192 ou 16384 |
| BPM pulando entre 40 e 180 | Movimento, pressão forte demais ou luz ambiente | Firme o dedo, pressione de leve, proteja o sensor da luz |
| SpO2 sempre “--” ou -999 | O algoritmo considera o sinal inválido (validSpo2 = 0) | Fique parado por 4 segundos, aqueça o dedo e prenda-o com uma tira |
| O código trava ou se comporta de forma estranha no Uno | Falta de RAM, outras bibliotecas grandes também carregadas | Mantenha os buffers de 16 bits, coloque os textos dentro de F() ou passe para um ESP32 |
O MAX30102 é um ótimo sensor para aprender, que mostra como pode ser elegante ler o corpo com luz de duas cores e um algoritmo esperto; só interprete as leituras como dados de experimento, não como resultados médicos. Se quiser reforçar a leitura de sensores via I2C, a exibição de valores num display e o registro de dados, no app BlueGrays você pode explorar projetos de medição como DHT11, LDR, LCD I2C, estação do tempo com OLED e registrador de temperatura, passo a passo, com esquemas do circuito e código pronto.
Perguntas frequentes
Qual é a precisão do SpO2 medido com o MAX30102?
Como os módulos hobby não são calibrados, o SpO2 pode se desviar vários pontos em relação a um oxímetro aprovado, e o movimento e a luz ambiente aumentam ainda mais essa diferença. Os resultados servem para experimentar e aprender e não devem ser usados em decisões de saúde.
O MAX30102 funciona com 5 V?
Como os módulos MAX30102 comuns têm um regulador na placa, o pino VIN pode ser alimentado com 3,3 V ou 5 V. Porém, em algumas placas os resistores de pull-up do I2C estão ligados a 1,8 V, e um Uno de 5 V pode não enxergar o sensor; nesse caso, é preciso passar o jumper de solda da placa para o lado de 3,3 V.
Qual é a diferença entre o MAX30100 e o MAX30102?
Os dois medem pulso e SpO2 com LEDs vermelho e IR. O MAX30102 é o chip mais novo; ele oferece resolução de ADC de até 18 bits, FIFO de 32 amostras e menor consumo de energia. No MAX30100, o ADC vai até 16 bits e a FIFO guarda 16 amostras.
Por que meu MAX30102 dá o erro “sensor not found”?
As causas mais comuns são os fios SDA e SCL invertidos, a falta da ligação de VIN ou GND e resistores de pull-up ligados a 1,8 V. Rode um sketch scanner I2C e veja se o endereço 0x57 aparece; se não aparecer, o problema está na ligação, não no código.
Quais são os valores normais de pulso e SpO2?
Em adultos em repouso, o pulso costuma ficar entre 60 e 100 batimentos por minuto e pode ser mais baixo em atletas. Em pessoas saudáveis, o SpO2 costuma ficar entre 95% e 100%. Se o seu sensor hobby mostrar um valor fora dessa faixa, confira primeiro as condições da medição e, se tiver uma preocupação real, recorra a um aparelho aprovado.
O MAX30102 consegue medir no pulso ou na orelha?
Como o sensor funciona por reflexão, ele também consegue captar a onda de pulso no pulso ou no lóbulo da orelha, mas nesses lugares o sinal é bem mais fraco que na ponta do dedo e muito sensível a movimento. Por isso, os smartwatches usam LEDs mais fortes, correção de movimento com ajuda de acelerômetro e algoritmos mais avançados.
Projetos para montar depois desta leitura
Ver todos os projetos
Temperatura e umidade com DHT11
Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

Medição de distância com HC-SR04 (Monitor Serial)
O sensor HC-SR04 funciona como um morcego que se orienta no escuro: emite um som que você não consegue ouvir, escuta o eco e mede a distância até o objeto à sua frente.

Medição da intensidade da luz com LDR
Quer ver a luminosidade do seu quarto em números? O LDR, um pequeno componente sensível à luz, mede a luz ambiente, e o Arduino exibe o valor na tela do computador a cada meio segundo.

Uso do display LCD com I2C
Dê ao seu Arduino um display próprio e faça-o escrever sua primeira mensagem. O display LCD de duas linhas é conectado com poucos fios; primeiro aparece uma saudação na linha de cima, depois uma…

Display LCD I2C com ESP32 (16x2)
Neste projeto, exibimos texto conectando um display LCD de 16x2 caracteres ao ESP32 pelo protocolo I2C. Com o I2C, controlamos o display usando apenas dois pinos de dados (SDA e SCL), dispensando o uso de seis ou mais pinos da conexão paralela tradicional. O código mostra uma mensagem fixa na primeira linha e um contador que aumenta a cada segundo na segunda linha. Na inicialização, também executamos um scanner I2C para mostrar o endereço do display no Monitor Serial (geralmente 0x27 ou 0x3F).

ESP32 HTTPClient + API de clima (com display OLED SSD1306)
Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Diferentemente da versão anterior com LCD I2C, aqui usamos um display OLED SSD1306 (128×64), que permite usar fontes grandes, ícones vetoriais e uma apresentação visual rica em uma única tela. Sete ícones vetoriais de condições do tempo (ensolarado, parcialmente nublado, nublado, chuvoso, com neve, com tempestade e com neblina) são desenhados durante a execução, sem arquivos bitmap.

ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
O modo de sono profundo do ESP32 reduz o consumo de corrente para ~10 µA ao desligar a CPU e a maioria dos periféricos, sendo essencial para dispositivos IoT alimentados por bateria. Neste projeto, usamos três fontes de despertar: um temporizador (15 segundos), um pino externo (EXT0 — botão no GPIO 33) e toque (T0/GPIO 4). As variáveis marcadas com RTC_DATA_ATTR são preservadas durante o sono profundo, mantendo os contadores de inicializações e de despertares por temporizador e botão.

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

