Visualizador de Batimentos Cardíacos em Tempo Real com LED Alimentado por ECG
Componentes e Materiais
| Componente | Quantidade |
|---|---|
| Dispositivo uECG | 1 |
| Arduino Nano R3 | 1 |
| Anel Adafruit NeoPixel: WS2812 5050 RGB LED | 1 |
| Bateria Li-Ion 1000mAh | 1 |
Ferramentas e Máquinas Necessárias
- Ferro de solda (genérico)
Sobre o Projeto
Por muitos anos eu só queria fazer algo com LEDs que pisque no ritmo dos meus batimentos cardíacos (e não apenas quando estou perfeitamente parado, e ainda assim pulando uma batida aqui e ali). Isso se mostrou surpreendentemente difícil, tentei e falhei por anos. Mas não mais!
Na verdade, todo o trabalho pesado é feito pelo uECG - um pequeno dispositivo ECG vestível que é open source e tem um pino de saída compatível com Arduino (esse pino vai alto/baixo a cada batida). Processar esses estados de pino é muito mais fácil que processar sinal de ECG, e tentei extrair o máximo dele.
ATUALIZAÇÃO: você pode querer conferir a 2ª iteração deste projeto, que recebe dados via enlace de rádio.
1. Esquemático
Como trabalhamos apenas com sinais digitais aqui, é muito simples. Mas como vestível seria muito mais confiável (e menor) se a maioria das conexões forem soldadas - para um teste rápido não é necessário, mas se você vai usá-lo durante atividade intensa, recomendo fortemente.
O esquemático é assim:

- Pino DI do anel LED vai para pino D11 (configurável no código)
- Pino DRV do dispositivo uECG vai para pino D3 (também configurável)
- Positivo da bateria vai para entrada 5V do Arduino e 5V do anel LED
- Negativo da bateria vai para GND do Arduino, GND do anel e GND do uECG
Usei bateria LiPo diretamente como entrada 5V - não é erro, se você conectar no Vin - não funcionará de forma confiável (regulador de tensão no Vin introduz queda de tensão e absolutamente não podemos pagar uma aqui). A questão é: Arduino é estável enquanto tensão de entrada não cai abaixo de 3,4 volts. Bateria LiPo começa em 4,2 volts quando totalmente carregada, e chega a 3,4 volts apenas quando resta menos de 15% de carga. Então com qualquer bateria maior que ~200 mAh você obtém tempo de operação decente. Além disso, lembre-se que a bateria deve ser conectada via algum conector :) Porque você vai querer desconectá-la do esquemático e carregar de vez em quando.
2. Código
O programa funciona de forma simples: lê constantemente o pino D3, e quando mudança é detectada - empurra o tempo dessa mudança para array de 20 elementos. Diferença entre primeiro e último elemento, dividida por 20, é tempo médio por batida (em milissegundos). Dividindo 1 minuto (60000 milissegundos) por esse número obtemos valor BPM. Você pode ajustar número de elementos no array. Número menor levaria a resposta mais rápida, mas resultados menos estáveis (qualquer problema na detecção de batida levaria a grande salto no BPM calculado). Número maior daria dados mais estáveis, mas resposta mais lenta quando BPM muda rápido.
Então BPM é mapeado para cor (azul->verde->amarelo->rosa->vermelho quando BPM vai de baixo para alto), e para número de LEDs: para 80 BPM oito segmentos acendem, para 110 - onze e assim por diante (escala também ajustável no código).
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
// Pino DI do anel LED
#define PIN 11
// número de pixels no anel
#define NUMPIXELS 16
// pino de entrada para conectar uECG
int in_pin = 3;
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
void setup() {
pixels.begin(); // Inicializa biblioteca NeoPixel.
pinMode(in_pin, INPUT); //define pino como entrada
digitalWrite(in_pin, 1); //habilita PULLUP: crítico, uECG não tem pull-up interno
}
// armazenamos últimas 20 batidas para média BPM sobre elas
// com valor maior, fica mais confiável,
// mas leva mais tempo para ver mudança na saída quando BPM muda
#define BEAT_HIST 20
long beats[BEAT_HIST];
void push_beat(long ms) //desloca todas batidas no array e insere atual
{
for(int x = 0; x < BEAT_HIST-1; x++)
{
beats[x] = beats[x+1];
}
beats[BEAT_HIST-1] = ms;
}
int get_bpm() //usando diferença de tempo entre primeira e última batidas
{
long dt = beats[BEAT_HIST-1] - beats[0];
long bpm = BEAT_HIST * 60000 / dt;
return bpm;
}
long last_pix_upd = 0; //para rastrear quando atualizamos pixels da última vez
int prev_in_state = 0; //estado anterior do pino de entrada: queremos processar apenas mudanças de estado
void loop()
{
long ms = millis();
int in_state = digitalRead(in_pin); //1 quando sem batida detectada, 0 em batida
if(in_state == 1 && prev_in_state == 0) //reage apenas à mudança
{
push_beat(ms);
}
prev_in_state = in_state;
if(ms - last_pix_upd > 10) //não atualiza pixels com muita frequência
{
int r, g, b;
last_pix_upd = ms;
int bpm = get_bpm();
int max_bright = 120; //valor de brilho máximo, max 255. Mas nem sempre quer no máximo :)
float dd = 20; //mudança em BPM entre tons de cor (azul->verde->amarelo->rosa->vermelho)
float t1 = 90, t2, t3, t4; //t1 - "base" BPM, menor que t1 seria azul
t2 = t1 + dd;
t3 = t2 + dd;
t4 = t3 + dd;
//código para mudar cor dependendo em qual faixa t1...t4 estamos agora
if(bpm < t1){ r = 0; g = 0; b = max_bright; }
else if(bpm < t2) { r = 0; g = max_bright * (bpm-t1)/dd; b = max_bright - g; }
else if(bpm < t3) { r = max_bright * (bpm-t2)/dd; g = max_bright - r; b = r/4; }
else if(bpm < t4) { r = max_bright; g = 0; b = max_bright/2 - max_bright * (bpm-t3)/(2*dd); }
else {r = max_bright; g = 0; b = 0; }
if(in_state) //quando não em batida, 1/4 intensidade, para que apenas batidas sejam destacadas
{
r *= 0.25;
g *= 0.25;
b *= 0.25;
}
int on_pixels = (bpm+5)/10; //número de LEDs usados: para 60 BPM, 6 LEDs acesos, para 120 - 12 etc
for(int i=0;i
3. Montagem como Vestível
É conveniente colocar o Arduino dentro do anel - combina tamanho quase perfeitamente. Bateria cabe perto também. Não esqueça que uECG é colocado no peito - então você precisa de um fio com conectores, primeiro coloca o sensor, depois veste a camisa com outros componentes, e então conecta o conector. Caso contrário seria realmente inconveniente de vestir - acredite, tentei ))



Basicamente é isso - se tudo foi feito certo, dentro de 30 segundos após conectar todos os conectores ele começará a piscar e indicar BPM.
4. Testes de Campo
Testei caminhando e correndo - e descobri que durante a corrida, a bateria quica bem sobre o sensor ECG, distorcendo suas leituras. Quando movi tudo um pouco, descobri que o fio conectando uECG ao Arduino é muito curto e puxa o sensor ECG a cada passo, distorcendo leituras novamente. No geral, obtive batidas confiáveis apenas caminhando e parado, mas não correndo - ainda acho que vou melhorar isso. O sensor em si, quando usei com camisa diferente, mostrou BPM correto durante a corrida também (verifiquei via seu app).
Além disso, descobri que LEDs no peito podem parecer legais mas são praticamente inúteis. É realmente inconveniente olhar para baixo para checar seu pulso. Acho que na próxima iteração farei algum tipo de pulseira de pulso que indicará batidas.
P.S. Se você tem interesse no projeto uECG - pode conferir sua página no hackaday, há muitos detalhes técnicos, designs de PCB, discussão e logs do projeto.
Código
- uECG_pixel_ring.ino
uECG_pixel_ring.ino Arduino
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
// Pino DI do anel LED
#define PIN 11
// número de pixels no anel
#define NUMPIXELS 16
// pino de entrada para conectar uECG
int in_pin = 3;
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
void setup() {
pixels.begin(); // Inicializa biblioteca NeoPixel.
pinMode(in_pin, INPUT); //define pino como entrada
digitalWrite(in_pin, 1); //habilita PULLUP: crítico, uECG não tem pull-up interno
}
// armazenamos últimas 20 batidas para média BPM sobre elas
// com valor maior, fica mais confiável,
// mas leva mais tempo para ver mudança na saída quando BPM muda
#define BEAT_HIST 20
long beats[BEAT_HIST];
void push_beat(long ms) //desloca todas batidas no array e insere atual
{
for(int x = 0; x < BEAT_HIST-1; x++)
{
beats[x] = beats[x+1];
}
beats[BEAT_HIST-1] = ms;
}
int get_bpm() //usando diferença de tempo entre primeira e última batidas
{
long dt = beats[BEAT_HIST-1] - beats[0];
long bpm = BEAT_HIST * 60000 / dt;
return bpm;
}
long last_pix_upd = 0; //para rastrear quando atualizamos pixels da última vez
int prev_in_state = 0; //estado anterior do pino de entrada: queremos processar apenas mudanças de estado
void loop()
{
long ms = millis();
int in_state = digitalRead(in_pin); //1 quando sem batida detectada, 0 em batida
if(in_state == 1 && prev_in_state == 0) //reage apenas à mudança
{
push_beat(ms);
}
prev_in_state = in_state;
if(ms - last_pix_upd > 10) //não atualiza pixels com muita frequência
{
int r, g, b;
last_pix_upd = ms;
int bpm = get_bpm();
int max_bright = 120; //valor de brilho máximo, max 255. Mas nem sempre quer no máximo :)
float dd = 20; //mudança em BPM entre tons de cor (azul->verde->amarelo->rosa->vermelho)
float t1 = 90, t2, t3, t4; //t1 - "base" BPM, menor que t1 seria azul
t2 = t1 + dd;
t3 = t2 + dd;
t4 = t3 + dd;
//código para mudar cor dependendo em qual faixa t1...t4 estamos agora
if(bpm < t1){ r = 0; g = 0; b = max_bright; }
else if(bpm < t2) { r = 0; g = max_bright * (bpm-t1)/dd; b = max_bright - g; }
else if(bpm < t3) { r = max_bright * (bpm-t2)/dd; g = max_bright - r; b = r/4; }
else if(bpm < t4) { r = max_bright; g = 0; b = max_bright/2 - max_bright * (bpm-t3)/(2*dd); }
else {r = max_bright; g = 0; b = 0; }
if(in_state) //quando não em batida, 1/4 intensidade, para que apenas batidas sejam destacadas
{
r *= 0.25;
g *= 0.25;
b *= 0.25;
}
int on_pixels = (bpm+5)/10; //número de LEDs usados: para 60 BPM, 6 LEDs acesos, para 120 - 12 etc
for(int i=0;i
Esquemáticos

Processo de manufatura
- Desfibrilador Externo: História, Design e Fabricação
- O Rolo de Massa: Das Origens Etruscas à Arte Moderna
- Coração Artificial: Tecnologia, História e Perspectivas Futuras
- Válvulas Cardíacas Artificiais: Tipos, História e Inovações Futuras
- Controle um LED com Sensor de Movimento PIR no Raspberry Pi
- Monitore a Temperatura da Sua Casa com Dashboard no Raspberry Pi
- Sistema Remoto de Monitoramento de Frequência Cardíaca com Alertas AWS IoT
- Monitoramento de Batimentos Cardíacos sem Contato via Smart Speakers: Um Sistema Revolucionário
- Tatuagem Eletrônica Baseada em Grafeno Oferece Monitoramento Cardíaco Contínuo e Preciso por Longos Períodos
- Junta de Articulação (Knuckle Joint) Explicada: Design, Aplicações e Características Principais