Monitoramento de gráfico de ECG com sensor de ECG AD8232 com Arduino

Publicado em por
Tempo de leitura: 6 minutes

Monitoramento de ECG com Sensor de ECG AD8232  no Arduino

As doenças cardíacas estão se tornando um grande problema nas últimas décadas e muitas pessoas morrem por causa de certos problemas de saúde. Portanto, doenças cardíacas não podem ser tomadas de ânimo leve. Ao analisar ou monitorar o sinal de ECG no estágio inicial, essa doença pode ser prevenida. Então, apresentamos este projeto, ou seja, monitoramento de ECG com sensor de ECG AD8232 e Arduino com gráfico de ECG.

O AD8232 é um pequeno chip usado para medir a atividade elétrica do coração. Esta atividade elétrica pode ser mapeada como um ECG ou eletrocardiograma. A eletrocardiografia é usada para ajudar a diagnosticar várias doenças cardíacas.

Portanto, neste projeto, faremos a interface do sensor de ECG AD8232 com o Arduino e observaremos o sinal de ECG em um plotter serial ou IDE de processamento.

Você pode verificar a versão avançada deste projeto aqui: Monitoramento de ECG baseado em IoT com sensor de ECG AD8232 e ESP32

 

Lista de Materiais

Nome dos ComponentesDescriçãoQuantidade
1Arduino BoardArduino UNO R3 (Ou Genérica)1https://amzn.to/39p4ueD
2Sensor ECGKit de sensor de ECG AD82321ML (Link)
3Fios de conexãoFios de Conexão20https://amzn.to/3qUjyXx
4ProtoBoard–1https://amzn.to/3t0EHkB

 

O que é um ECG?

Um ECG é um papel ou registro digital dos sinais elétricos do coração. Também é chamado de eletrocardiograma ou EKG. O ECG é usado para determinar a frequência cardíaca, ritmo cardíaco e outras informações sobre a condição do coração. Os ECGs são usados para ajudar a diagnosticar arritmias cardíacas, ataques cardíacos, função do marca-passo e insuficiência cardíaca.

O ECG pode ser analisado estudando os componentes da forma de onda. Esses componentes da forma de onda indicam a atividade elétrica cardíaca. A primeira parte superior do traçado de ECG é a onda P. Indica contração atrial.

O complexo QRS começa com Q, uma pequena deflexão para baixo, seguida por uma grande deflexão para cima, um pico (R); e então uma onda S descendente. Este complexo QRS indica despolarização e contração ventricular.

Finalmente, a onda T, que normalmente é uma forma de onda ascendente menor, representando a repolarização ventricular.

 

Usos médicos do ECG

Um eletrocardiograma pode ser uma forma útil de descobrir se sua pressão alta causou algum dano ao coração ou aos vasos sanguíneos. Por causa disso, pode ser necessário fazer um ECG quando for diagnosticado pela primeira vez com hipertensão.

Algumas das coisas que uma leitura de ECG pode detectar são:

1. colesterol obstruindo o suprimento de sangue do seu coração
2. um ataque cardíaco no passado
3. alargamento de um lado do coração
4. ritmos cardíacos anormais

 

Sensor de ECG AD8232

Este sensor é uma placa econômica usada para medir a atividade elétrica do coração. Essa atividade elétrica pode ser mapeada como um ECG ou eletrocardiograma e gerada como uma leitura analógica. Os ECGs podem ser extremamente ruidosos, o Monitor de frequência cardíaca com eletrodo único AD8232 atua como um amplificador operacional para ajudar a obter um sinal claro dos intervalos PR e QT facilmente.

O AD8232 é um bloco de condicionamento de sinal integrado para ECG e outras aplicações de medição biopotencial. Ele é projetado para extrair, amplificar e filtrar pequenos sinais biopotenciais na presença de condições ruidosas, como aquelas criadas por movimento ou colocação remota de eletrodos.

O módulo AD8232 rompe nove conexões do IC às quais você pode soldar pinos, fios ou outros conectores. SDN, LO+, LO-, OUTPUT, 3,3 V, GND fornecem pinos essenciais para operar este monitor com um Arduino ou outra placa de desenvolvimento. Também são fornecidos nesta placa os pinos RA (braço direito), LA (braço esquerdo) e RL (perna direita) para conectar e usar seus próprios sensores personalizados. Além disso, há uma luz indicadora de LED que pulsará no ritmo de um batimento cardíaco.

Nota: Este produto NÃO é um dispositivo médico e não se destina a ser usado como tal ou como um acessório para diagnosticar ou tratar quaisquer condições.

 

Diagrama de circuito/Conexão entre o Arduino e o sensor de ECG AD8232

O monitor de freqüência cardíaca AD8232 interrompe nove conexões do IC. Tradicionalmente, chamamos essas conexões de “pinos” porque elas vêm dos pinos do IC, mas na verdade são orifícios aos quais você pode soldar fios ou pinos de cabeçalho.

Vamos conectar cinco dos nove pinos da placa ao Arduino. Os cinco pinos de que você precisa são identificados como GND, 3.3v, OUTPUT, LO- e LO+.

 

Colocação do sensor de ECG AD8232 no corpo

Recomenda-se encaixar as almofadas do sensor nos eletrodos antes da aplicação no corpo. Quanto mais perto do coração estiverem as almofadas, melhor será a medição. Os cabos são codificados por cores para ajudar a identificar o posicionamento correto.

 

Vermelho: RA (braço direito)
Amarelo: LA (braço esquerdo)
Verde: RL (perna direita)

 

Código fonte/Programa do Arduino

void setup() {
   Serial.begin(9600);
   pinMode(10, INPUT); // Configuração para detecção de derivações LO +
   pinMode(11, INPUT); // Configuração para detecção de leads off LO -
}
 
void loop() {
 
  if((digitalRead(10) == 1)||(digitalRead(11) == 1)){
     Serial.println('!');
  } else {
    // envia o valor da entrada analógica 0:
    Serial.println(analogRead(A0));
  }
  // Espere um pouco para evitar que os dados seriais saturem
  delay(1);
}

Processando Código-Fonte/Programa IDE

Uma vez que o código é carregado, você pode ver o valor no monitor serial e também na plotadora serial.

Mas se você deseja um gráfico separado e deseja traçá-lo no Processing IDE, pode usar o código abaixo e rodar.

import processing.serial.*;
 
Serial myPort;        // A porta serial
int xPos = 1;         // posição horizontal do gráfico
float height_old = 0;
float height_new = 0;
float inByte = 0;
int BPM = 0;
int beat_old = 0;
float[] beats = new float[500];  // Usado para calcular o BPM médio
int beatIndex;
float threshold = 620.0;  // Limite em que ocorre o cálculo de BPM
boolean belowThreshold = true;
PFont font;
 
void setup () {
  // definir o tamanho da janela:
  size(1000, 400);        
 
  // Lista todas as portas seriais disponíveis
  println(Serial.list());
  // Abra qualquer porta que você está usando.
  myPort = new Serial(this, Serial.list()[2], 9600);
  // não gere um serialEvent () a menos que você obtenha um caractere de nova linha:
  myPort.bufferUntil('\n');
  // definir fundo inicial:
  background(0xff);
  font = createFont("Ariel", 12, true);
}
 
 
void draw () {
     // Mapeie e desenhe a linha para o novo ponto de dados
     inByte = map(inByte, 0, 1023, 0, height);
     height_new = height - inByte; 
     line(xPos - 1, height_old, xPos, height_new);
     height_old = height_new;
    
      // na borda da tela, volte ao início:
      if (xPos >= width) {
        xPos = 0;
        background(0xff);
      } 
      else {
        // incrementa a posição horizontal:
        xPos++;
      }
      
      // desenhe texto para BPM periodicamente
      if (millis() % 128 == 0){
        fill(0xFF);
        rect(0, 0, 200, 20);
        fill(0x00);
        text("BPM: " + inByte, 15, 10);
      }
}
  
void serialEvent (Serial myPort) 
{
  // obtenha a string ASCII:
  String inString = myPort.readStringUntil('\n');
 
  if (inString != null) 
  {
    // apare qualquer espaço em branco:
    inString = trim(inString);
 
    // Se a detecção de derivações for verdadeira, notifique com linha azul
    if (inString.equals("!")) 
    { 
      stroke(0, 0, 0xff); // Defina o curso para azul (R, G, B)
      inByte = 512;  // meio do intervalo ADC (linha plana)
    }
    // Se os dados são bons, deixe-os passar
    else 
    {
      stroke(0xff, 0, 0); //Set stroke to red ( R, G, B)
      inByte = float(inString); 
      
      // verificação de cálculo de BPM
      if (inByte > threshold && belowThreshold == true)
      {
        calculateBPM();
        belowThreshold = false;
      }
      else if(inByte < threshold)
      {
        belowThreshold = true;
      }
    }
  }
}
  
void calculateBPM () 
{  
  int beat_new = millis();    // obtém o milissegundo atual
  int diff = beat_new - beat_old;    // encontre o tempo entre as duas últimas batidas
  float currentBPM = 60000 / diff;    // converter em batidas por minuto
  beats[beatIndex] = currentBPM;  // armazene em array para converter a média
  float total = 0.0;
  for (int i = 0; i < 500; i++){
    total += beats[i];
  }
  BPM = int(total / 500);
  beat_old = beat_new;
  beatIndex = (beatIndex + 1) % 500;  // percorre a matriz em vez de usar a fila FIFO
}

Se o sketch do processing não funcionar, você pode precisar modificar a seguinte linha:

myPort = new Serial(this, Serial.list()[2], 9600);

Aqui, 2 é o número da porta, substitua-o por 1,3,4,5 ou qualquer que seja a sua porta Arduino.

Você pode verificar a versão avançada deste projeto aqui: Monitoramento de ECG baseado em IoT.

 
Twittar
Compartilhar
Compartilhar
0 Compart.