Monitoramento de ECG baseado em IoT com Sensor de ECG AD8232 e ESP32

Publicado em 25/01/202127/01/2021 por cacpnrj

Tempo de leitura: 8 minutes

Neste tutorial aprenderemos como monitorar o mesmo gráfico de ECG online em qualquer plataforma de nuvem IoT. Para isso, faremos a interface do sensor de ECG AD8232 com o ESP32. E então geraremos um sinal de ECG conectando as derivações de ECG ao tórax ou à mão. Usando parâmetros Ubidots como API Key ou Token, enviaremos o gráfico de ECG para a nuvem usando MQTT Broker. Este projeto também pode ser feito usando a placa NodeMCU ESP8266, mas as conexões e o programa precisam ser modificados.

As doenças cardíacas estão se tornando um grande problema desde as ú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. Portanto, apresentamos este projeto, ou seja, monitoramento de ECG baseado em IoT com sensor de ECG AD8232 e ESP32.

Conteudo

Componentes necessários

Os componentes necessários para estes projetos estão listados abaixo. Todos esses componentes podem ser adquiridos online na Amazon ou MercadoLivre.

S.N.	Nome dos Componentes	Descrição	Quantidade
1	ESP32 Board	Placa de desenvolvimento ESP32 ESP-32S (ESP-WROOM-32)	1	https://amzn.to/2KO0ACy
2	ECG Sensor	Kit de sensor de ECG AD8232	1	ML (Link)
3	Data Cable	Cabo de dados micro USB 5V	1	https://amzn.to/3iGzMk9
4	USB Adapter	Adaptador USB 5V Volt	1	https://amzn.to/39XppVb
5	ProtoBoard	–	1	https://amzn.to/3pj9wyH

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: Interface do sensor de ECG AD8232 com ESP32

Para fazer a interface do sensor de ECG AD8232 com o chip ESP32 IOT, siga o diagrama de circuito acima. Alimente o AD8232 com 3,3 V de ESP32 e conecte o GND ao GND. O pino de saída do AD8232 é um sinal analógico e é conectado ao pino VP do ESP32. Da mesma forma, LO+ e L0- de AD8232 está conectado a D2 e D3 de ESP32.

Lembre-se de que existem muitos fornecedores que fazem o ESP32. Todos aqueles ESP32 têm mapeamento de pinos diferentes. Eu usei ESP32 wroom 32 Board. Se você estiver usando qualquer outra placa, por favor, tome cuidado com os pinos ESP32 ao conectar ao AD8232.

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)

Eu conectei por ESP32 com AD8232 à minha mão ou simplesmente você pode colocar em seu peito conforme mostrado na figura abaixo.

Configurando uma conta Ubidots

Para publicar os dados na nuvem IoT, precisamos de alguma plataforma IoT. Então Ubidots é uma dessas plataformas. Ubidots oferece uma plataforma para desenvolvedores que lhes permite capturar facilmente dados do sensor e transformá-los em informações úteis. Use a plataforma Ubidots para enviar dados para a nuvem a partir de qualquer dispositivo habilitado para Internet. Você pode usar ela totalmente de Graça se for para Estudo (https://ubidots.com/stem/)

Etapa 1: Criação de conta Ubidots

Vá para ubidots.com e crie uma conta. Você terá um período experimental de 30 dias.

Etapa 2: Criação de dispositivo e adição de variáveis

Agora configure um dispositivo Ubidots. Para criá-lo, vá para a seção Dispositivos (Dispositivos> Dispositivos). Crie um novo dispositivo com o nome esp32.

Depois que o dispositivo for criado, crie uma nova variável renomeando a variável para sensor.

Etapa 3: Criação de painéis

Vamos configurar um painel do Ubidots. Para criá-lo, vá para a seção Painel (Dados> Painel)

Etapa 4: Adicionando Novos Widgets

Clique no sinal + no lado direito e em “Adicionar novo widget” e selecione o seu widget.

Agora, selecione o tipo de widget que deseja exibir. No meu caso, escolho o “Gráfico de linha”:

Em seguida, selecione a variável desejada para exibir os dados. Ubidots permite que você atribua um nome de widget personalizado, cor, período de dados a serem exibidos e muito mais. Para finalizar a criação do widget, pressione o ícone verde.

Selecione seu dispositivo e variáveis criados anteriormente, conforme mostrado na figura abaixo

Código Fonte/Programa

O código-fonte para monitoramento de ECG baseado em IoT com sensor de ECG AD8232 e ESP32 é fornecido abaixo. Copie este código e altere os seguintes parâmetros.

1. WIFISSID: Seu SSID WiFi
2. SENHA: Sua senha WiFi
3. TOKEN: Seu TOKEN Ubidots (fornecido no site)
4. MQTT_CLIENT_NAME: Sua própr ia string ASCII de 8-12 caracteres alfanuméricos.

#include <WiFi.h>
#include <PubSubClient.h>
 
#define WIFISSID "Alexahome"      // Coloque seu WifiSSID aqui
#define PASSWORD "hngzhowxiantan" // Coloque sua senha wifi aqui
#define TOKEN "BBFF-RJ8ABBbh6G2ECGU0rkjRSOdXqhUnvj" // Coloque o TOKEN do seu Ubidots
#define MQTT_CLIENT_NAME "alexnewton"               // Nome do cliente MQTT, insira sua própria sequência ASCII de 8-12 caracteres alfanuméricos;
                                                    // deve ser uma string ascii aleatória e única e diferente de todos os outros dispositivos
 
/****************************************
 * Definir constantes
 ****************************************/
#define VARIABLE_LABEL "sensor" // Atribuir o rótulo da variável
#define DEVICE_LABEL "esp32"    // Atribuir o rótulo do dispositivo
 
#define SENSOR A0 // Defina o A0 como SENSOR
 
char mqttBroker[]  = "industrial.api.ubidots.com";
char payload[100];
char topic[150];
// Espaço para armazenar valores para enviar
char str_sensor[10];
 
/****************************************
 * Auxiliar Functions
 ****************************************/
WiFiClient ubidots;
PubSubClient client(ubidots);
 
void callback(char* topic, byte* payload, unsigned int length) {
  char p[length + 1];
  memcpy(p, payload, length);
  p[length] = NULL;
  Serial.write(payload, length);
  Serial.println(topic);
}
 
void reconnect() {
  // Loop até estarmos reconectados
  while (!client.connected()) {
    Serial.println("Tentando conexão MQTT...");
    
    //Tentativa de conexão
    if (client.connect(MQTT_CLIENT_NAME, TOKEN, "")) {
      Serial.println("Connected");
    } else {
      Serial.print("Failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 2 seconds");
      // Wait 2 seconds before retrying
      delay(2000);
    }
  }
}
 
/****************************************
 * Main Functions
 ****************************************/
void setup() {
  Serial.begin(115200);
  WiFi.begin(WIFISSID, PASSWORD);
  // Atribua o pino como INPUT
  pinMode(SENSOR, INPUT);
 
  Serial.println();
  Serial.print("Esperando por WiFi ...");
  
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }
  
  Serial.println("");
  Serial.println("WiFi conectado");
  Serial.println("Endereço de IP:");
  Serial.println(WiFi.localIP());
  client.setServer(mqttBroker, 1883);
  client.setCallback(callback);  
}
 
void loop() {
  if (!client.connected()) {
    reconnect();
  }
 
  sprintf(topic, "%s%s", "/v1.6/devices/", DEVICE_LABEL);
  sprintf(payload, "%s", ""); // Cleans the payload
  sprintf(payload, "{\"%s\":", VARIABLE_LABEL); // Adiciona o rótulo da variável
  
  float sensor = analogRead(SENSOR); 
  
  /*4 é a largura mínima, 2 é a precisão; valor flutuante é copiado para str_sensor*/
  dtostrf(sensor, 4, 2, str_sensor);
  
  sprintf(payload, "%s {\"value\": %s}}", payload, str_sensor); // Adds the value
  Serial.println("Publicação de dados na nuvem Ubidots");
  client.publish(topic, payload);
  client.loop();
  delay(500);
}

Agora selecione os seguintes parâmetros nas ferramentas e carregue o código para ESP32. Em alguns casos, o código não é carregado. Portanto, pressione o botão de inicialização ao enviar o código para ESP32.

Verificando dados e gráfico de ECG em Ubidots

Assim que o código for carregado para a Placa ESP32, clique no monitor serial. Se o ESP32 se conectar ao wi-fi, ele começará a enviar dados para a nuvem Ubidots.