Monitoramento da saúde do paciente baseado em IoT usando ESP8266 e Arduino

Tempo de leitura: 12 minutes

Sistema de monitoramento de saúde do paciente usando ESP8266 e Arduino:

Com toneladas de novas empresas de tecnologia de saúde, a IoT está revolucionando rapidamente o setor de saúde. Neste projeto, projetamos o sistema de monitoramento da saúde do paciente baseado em IoT usando ESP8266 e Arduino. A plataforma IoT usada neste projeto é ThingSpeak. ThingSpeak é um aplicativo de código aberto da Internet das Coisas (IoT) e API para armazenar e recuperar dados usando o protocolo HTTP na Internet ou por meio de uma rede local. Este dispositivo IoT pode ler a taxa de pulso e medir a temperatura ambiente. Ele monitora continuamente a taxa de pulso e a temperatura ambiente e os atualiza para uma plataforma IoT.

O Arduino Sketch executado no dispositivo implementa as várias funcionalidades do projeto, como leitura de dados do sensor, convertendo-os em strings, passando-os para a plataforma IoT e exibindo a taxa de pulso medida e a temperatura no LCD de caracteres.

Você pode verificar nossos projetos relacionados ao sensor de pulso se você for um iniciante:
1. Monitor de batimento cardíaco/pulso/taxa de BPM usando Arduino e sensor de pulso.
2. Monitoramento de frequência de pulso pela Internet usando ThingSpeak e ESP8266.
3. Display de ECG usando sensor de pulso com OLED e Arduino. (Breve)
Não deixe de ver novamente este artigo pois estes estão em andamento.

Diagrama de bloco:

Este é um diagrama de blocos simples que explica o sistema de monitoramento de saúde do paciente baseado em IoT usando ESP8266 e Arduino. O sensor de pulso e os sensores de temperatura LM35 medem o BPM e a temperatura ambiental, respectivamente. O Arduino processa o código e o exibe em um display LCD de 16 * 2. O módulo ESP8266 Wi-Fi se conecta ao Wi-Fi e envia os dados para o servidor do dispositivo IoT. O servidor IoT usado aqui é Thingspeak. Finalmente, os dados podem ser monitorados de qualquer parte do mundo, acessando o canal Thingspeak.

 

Lista de materiais:

Estes itens a venda são sujestão na Amazon e ML, no Amazon mesmo se for importando a entrega é garantida, visite outras itens para Arduino/IOT (Sujestão de Eletrônica)

Nome dos Componentes Descrição QTD Amazon / Ml
1 Placa Arduino Arduino UNO/Nano ou qualquer outra placa 1 https://amzn.to/2NVtRfC
2 ESP8266-01 Módulo Wifi ESP8266-01 1 https://amzn.to/3avlKhA
3 LCD Display Display LCD 16×2 JHD162A 1 https://amzn.to/36ELZAO
4 Potenciômetro 10K 1 ML (Link)
5 Sensor de pulso Sensor de pulso de pulsesensor.com 1 ML (Link)
6 Sensor de temperatura Sensor Analógico de Temperatura LM35 1 https://amzn.to/2NZK7MF
7 Resistor 2K 1 Ml (Link)
8 Resistor 1K 1 Ml (Link)
8 LED LED 5mm qualquer Cor 1 https://amzn.to/3cD36qB
9 Fios de Conexão Fios de Conexão 10-20 https://amzn.to/3avnp6O
10 ProtoBoard 1 https://amzn.to/2YF4Ffp

 

Sensor de pulso:

O Sensor de pulso é um sensor de frequência cardíaca plug-and-play para Arduino. Ele pode ser usado por estudantes, artistas, atletas, criadores e desenvolvedores de jogos e dispositivos móveis que desejam incorporar facilmente dados de frequência cardíaca ao vivo em seus projetos. A essência é um circuito amplificador óptico integrado e um sensor de circuito eliminador de ruído. Prenda o sensor de pulso no lóbulo da orelha ou na ponta do dedo e conecte-o ao Arduino, pronto para ler a frequência cardíaca. Além disso, possui um código de demonstração do Arduino que o torna fácil de usar.

O sensor de pulso possui três pinos: VCC, GND e Pino Analógico.

Há também um LED no centro deste módulo sensor que ajuda a detectar os batimentos cardíacos. Abaixo do LED, há um circuito de eliminação de ruído que deve evitar que o ruído afete as leituras.

Sensor de temperatura LM35:

A série LM35 são dispositivos de temperatura de circuito integrado de precisão com uma tensão de saída linearmente proporcional à temperatura centígrada. O dispositivo LM35 tem uma vantagem sobre os sensores de temperatura linear calibrados em Kelvin, já que o usuário não precisa subtrair uma grande tensão constante da saída para obter uma escala Centígrada conveniente. O dispositivo LM35 não requer nenhuma calibração externa ou ajuste para fornecer precisões típicas de ± ¼°C em temperatura ambiente e ± ¾°C em uma faixa de temperatura completa de −55°C a 150°C.

ESP8266:

O ESP8266 é um dispositivo muito fácil de usar e de baixo custo para fornecer conectividade à Internet para seus projetos. O módulo pode funcionar tanto como um ponto de acesso (pode criar hotspot) e como uma estação (pode se conectar a Wi-Fi), portanto, pode facilmente buscar dados e enviá-los para a internet tornando a Internet das Coisas o mais fácil possível. Ele também pode buscar dados da Internet usando APIs, portanto, seu projeto pode acessar qualquer informação que esteja disponível na Internet, tornando-o mais inteligente. Outro recurso interessante deste módulo é que ele pode ser programado usando o IDE do Arduino, o que o torna muito mais amigável.

O módulo ESP8266 funciona apenas com 3,3 V, qualquer coisa acima de 3,7 V mataria o módulo, portanto, tome cuidado com seus circuitos. Aqui está a descrição dos pinos.

Pino 1: Terra: Conectado ao terra do circuito
Pino 2: Tx / GPIO – 1: Conectado ao pino Rx do programador / uC para carregar o programa
Pino 3: GPIO – 2: Pino de entrada / saída de uso geral
Pino 4: CH_EN: Chip Enable / Active high
Pino 5: Flash / GPIO – 0: Pino de entrada / saída de uso geral
Pino 6: Redefinir: redefine o módulo
Pino 7: RX / GPIO – 3: Pino de entrada / saída de uso geral
Pino 8: Vcc: Conectar apenas a + 3,3 V

 

Diagrama de circuito e conexões:

Para projetar um sistema de monitoramento de saúde do paciente baseado em IoT usando ESP8266 e Arduino, monte o circuito conforme mostrado na figura abaixo.

  1. Conecte o pino de saída do sensor de pulso a A0 do Arduino e outros dois pinos a VCC e GND.
  2. Conecte o pino de saída do sensor de temperatura LM35 a A1 do Arduino e outros dois pinos a VCC e GND.
  3. Conecte o LED ao pino digital 7 do Arduino por meio de um resistor de 220 ohms.
  4. Conecte o pino 1,3,5,16 do LCD ao GND.
  5. Conecte o pino 2,15 do LCD ao VCC.
  6. Conecte o pino 4,6,11,12,13,14 do LCD ao pino digital 12,11,5,4,3,2 do Arduino.
  7. O pino RX do ESP8266 funciona em 3,3 V e não se comunicará com o Arduino quando o conectarmos diretamente ao Arduino. Então, teremos que fazer um divisor de tensão para ele que irá converter 5V em 3,3V. Isso pode ser feito conectando o resistor 2.2K e 1K. Assim, o pino RX do ESP8266 é conectado ao pino 10 do Arduino por meio dos resistores.
  8. Conecte o pino TX do ESP8266 ao pino 9 do Arduino.

 

Configurando o ThingSpeak:

ThingSpeak fornece uma ferramenta muito boa para projetos baseados em IoT. Ao usar o site ThingSpeak, podemos monitorar nossos dados e controlar nosso sistema pela Internet, usando os canais e páginas da web fornecidos pela ThingSpeak. Portanto, primeiro você precisa se inscrever no ThingSpeak. Visite https://thingspeak.com e crie uma conta.

Em seguida, crie um novo canal e configure o que quiser. O tutorial no vídeo abaixo. Siga o vídeo para mais esclarecimentos.

Em seguida, crie as chaves de API. Esta chave é necessária para programar modificações e configurar seus dados.

Em seguida, faça upload do código para o Arduino UNO montando o circuito mostrado acima. Abra o monitor serial e ele se conectará automaticamente ao Wi-Fi e configurará tudo.

Agora clique nos canais para que você possa ver o streaming de dados online, ou seja, IoT Based Patient Health Monitoring System usando ESP8266 e Arduino, conforme mostrado na figura aqui.

 

Código Fonte / Programa:

O código-fonte para o projeto IoT Based Patient Health Monitoring System usando ESP8266 e Arduino é fornecido abaixo. Simplesmente copie o código e cole-o em seu IDE Arduino, compile-o e carregue-o na sua placa Arduino UNO.

#include <LiquidCrystal.h>
#include <SoftwareSerial.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

float pulse = 0;
float temp = 0;
SoftwareSerial ser(9,10); 
String apiKey = "OO707TGA1BLUNN12";   // insira seu key
 
// Variáveis
int pulsePin = A0; // Fio roxo do sensor de pulso conectado ao pino analógico 0
int blinkPin = 7 ; // pino a piscar led a cada batida
int fadePin = 13; // alfinete para fazer uma piscadela de desbotamento elegante a cada batida
int fadeRate = 0; // usado para acender o LED com PWM no fadePin
 
// Variáveis voláteis, usadas na rotina de serviço de interrupção!
volatile int BPM; // int que mantém o analógico bruto em 0. atualizado a cada 2 ms
volatile int Signal; // mantém os dados brutos recebidos
volatile int IBI = 600; // int que mantém o intervalo de tempo entre as batidas! Deve ser semeado!
volatile boolean Pulse = false; // "Verdadeiro" quando a pulsação ao vivo do usuário é detectada. "Falso" quando não é "batida ao vivo".
volatile boolean QS = false; // torna-se verdade quando Arduoino encontra uma batida.
 
// Regards Serial OutPut - Configure isso de acordo com suas necessidades
static boolean serialVisual = true; // Definido como 'falso' por padrão. Redefina para 'true' para ver o Arduino Serial Monitor ASCII Visual Pulse
volatile int rate[10]; // matriz para conter os últimos dez valores IBI
volatile unsigned long sampleCounter = 0; // usado para determinar o tempo de pulso
volatile unsigned long lastBeatTime = 0; // costumava encontrar IBI
volatile int P = 512; // usado para encontrar o pico na onda de pulso, semeado
volatile int T = 512; // usado para encontrar o vale na onda de pulso, semeado
volatile int thresh = 525; // costumava encontrar o momento instantâneo de batimento cardíaco, semeado
volatile int amp = 100; // usado para manter a amplitude da forma de onda de pulso, semeada
volatile boolean firstBeat = true; // usado para semear a matriz de taxa, então começamos com BPM razoável
volatile boolean secondBeat = false; // usado para semear a matriz de taxa, então começamos com BPM razoável
 
void setup()
{
   lcd.begin(16, 2);
   pinMode(blinkPin,OUTPUT); // pino que piscará no ritmo do seu coração!
   pinMode(fadePin,OUTPUT); // pino que vai desaparecer com o seu batimento cardíaco!
   Serial.begin(115200); // concordamos em falar rápido!
   interruptSetup(); // configura para ler o sinal do sensor de pulso a cada 2 ms
 
   // SE VOCÊ ESTIVER ALIMENTANDO O Sensor de pulso COM TENSÃO MENOR QUE A TENSÃO DA PLACA
 
   // DESCOMENTE A PRÓXIMA LINHA E APLIQUE ESSA TENSÃO AO PINO A-REF
   // analogReference(EXTERNAL);
 
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print(" Saúde do Pacienteh");
  lcd.setCursor(0,1);
  lcd.print(" Monitoramento ");
  delay(4000);
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Inicializando....");
  delay(5000);
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Obtendo dados....");
  ser.begin(9600);
  ser.println("AT");
  delay(1000);
  ser.println("AT+GMR");
  delay(1000);
  ser.println("AT+CWMODE=3");
  
  delay(1000);
  ser.println("AT+RST");
  delay(5000);
  ser.println("AT+CIPMUX=1");
  delay(1000);
 
  String cmd="AT+CWJAP=\"Alexahome\",\"98765432\"";
  ser.println(cmd);
  delay(1000);
  ser.println("AT+CIFSR");
  delay(1000);
}


// Onde a mágica acontece
void loop()
{
  serialOutput();
  if (QS == true) // Uma pulsação foi encontrada
  {
 
    // BPM e IBI foram determinados
    // Quantified Self "QS" verdadeiro quando o arduino encontra uma pulsação
    fadeRate = 255; // Faz o LED Fade Effect acontecer, defina a variável 'fadeRate' para 255 para fade LED com pulso
    serialOutputWhenBeatHappens(); // A Beat Happened, envie para serial.
    QS = false; // redefine o sinalizador Quantified Self para a próxima vez
  }
  ledFadeToBeat(); // Faz o LED Fade Effect Acontecer
  delay(20); // dar um tempo
  read_temp();
  esp_8266();
}

void ledFadeToBeat()
{
  fadeRate -= 15; // definir o valor de desvanecimento do LED
  fadeRate = constrain(fadeRate,0,255); // evita que o valor de desvanecimento do LED passe para números negativos!
  analogWrite(fadePin,fadeRate); // fade LED
}

void interruptSetup()
{
  // Inicializa o Timer2 para lançar uma interrupção a cada 2 ms.
  TCCR2A = 0x02; // DESATIVAR PWM NOS PINOS DIGITAIS 3 E 11 E ENTRE NO MODO CTC
  TCCR2B = 0x06; // NÃO FORCE COMPARE, 256 PRESCALER
  OCR2A = 0X7C; // DEFINA O TOPO DA CONTAGEM PARA 124 PARA A TAXA DE AMOSTRA DE 500 Hz
  TIMSK2 = 0x02; // ATIVAR A INTERRUPÇÃO NA CORRESPONDÊNCIA ENTRE TIMER2 E OCR2A
  sei(); //CERTIFIQUE-SE DE QUE AS INTERRUPÇÕES GLOBAIS ESTÃO ATIVADAS
}

void serialOutput()
{ // Decida como produzir serial.
   if (serialVisual == true)
  {
    arduinoSerialMonitorVisual('-', Signal); // vai para a função que torna o Serial Monitor Visualizer
  } else {
    sendDataToSerial('S', Signal); // vai para a função sendDataToSerial
  }
}

void serialOutputWhenBeatHappens()
{
  if (serialVisual == true) // Código para fazer o Serial Monitor Visualizer funcionar
  {
    Serial.print("*** Batimento cardíaco aconteceu *** "); // ASCII Art Madness
    Serial.print("BPM: ");
    Serial.println(BPM);
  } else {
    sendDataToSerial('B',BPM); // enviar frequência cardíaca com um prefixo 'B'
    sendDataToSerial('Q',IBI); // enviar tempo entre batidas com um prefixo 'Q'
  }
}

void arduinoSerialMonitorVisual(char symbol, int data )
{
  const int sensorMin = 0; // sensor mínimo, descoberto por meio de experimento
  const int sensorMax = 1024; // sensor máximo, descoberto por meio de experimento
  int sensorReading = data; // mapeia o intervalo do sensor para um intervalo de 12 opções:
  int range = map(sensorReading, sensorMin, sensorMax, 0, 11);
  // faça algo diferente dependendo do
  // valor do intervalo:
  switch (range)
  {
    case 0:
      Serial.println(""); /////ASCII Art Madness
      break;
    case 1:
      Serial.println("---");
      break;
    case 2:
      Serial.println("------");
      break;
    case 3:
      Serial.println("---------");
      break;
    case 4:
      Serial.println("------------");
      break;
    case 5:
      Serial.println("--------------|-");
      break;  
    case 6:
      Serial.println("--------------|---");
      break; 
    case 7:
      Serial.println("--------------|-------");
      break;
    case 8:
      Serial.println("--------------|----------");
      break;
    case 9:
      Serial.println("--------------|----------------");
      break;
    case 10:
      Serial.println("--------------|-------------------");
      break;
    case 11:
      Serial.println("--------------|-----------------------");
      break;
  }
}
 
void sendDataToSerial(char symbol, int data )
{
  Serial.print(symbol);
  Serial.println(data);
}

ISR(TIMER2_COMPA_vect) // acionado quando o Timer2 conta até 124
{
  cli(); // desabilita interrupções enquanto fazemos isso
  Signal = analogRead(pulsePin); // leia o sensor de pulso
  sampleCounter += 2; // manter o controle do tempo em mS com esta variável
  int N = sampleCounter - lastBeatTime; // monitore o tempo desde a última batida para evitar ruído
  // encontre o pico e o vale da onda de pulso
 
  if(Signal < thresh && N > (IBI/5)*3) // evite ruído dicrótico esperando 3/5 do último IBI
  {
    if (Signal < T) // T is the trough
    {
      T = Signal; // acompanhe o ponto mais baixo da onda de pulso
    }
  }
  if(Signal > thresh && Signal > P)
  { // condição de limite ajuda a evitar ruído
    P = Signal; // P is the peak
  } // acompanha o ponto mais alto da onda de pulso
  // AGORA É HORA DE PROCURAR A BATIDA CARDÍACA
  // o sinal aumenta de valor toda vez que há um pulso
  if (N > 250)
  { // evite ruído de alta frequência
    if ( (Signal > thresh) && (Pulse == false) && (N > (IBI/5)*3) )
    {
      Pulse = true; // definir o sinalizador de pulso quando pensarmos que há um pulso
      digitalWrite(blinkPin,HIGH); // ligue o LED do pino 13
      IBI = sampleCounter - lastBeatTime; // medir o tempo entre batidas em mS
      lastBeatTime = sampleCounter; // mantenha o controle do tempo para o próximo pulso
 
      if(secondBeat)
      { // se esta é a segunda batida, se secondBeat == TRUE
        secondBeat = false; // clear secondBeat flag
        for(int i=0; i<=9; i++) // seed the running total to get a realisitic BPM at startup
        {
          rate[i] = IBI;
        }
      }
      if(firstBeat) // se for a primeira vez que encontramos uma batida, se firstBeat == TRUE
      {
        firstBeat = false; // limpar sinalizador firstBeat
        secondBeat = true; // definir a segunda bandeira da batida
        sei(); // habilitar interrupções novamente
        return; // O valor IBI não é confiável, portanto, descarte-o
      }
      // mantém um total corrente dos últimos 10 valores IBI
      word runningTotal = 0; // limpar a variável runningTotal
      for(int i=0; i<=8; i++)
      { // deslocar dados na matriz de taxas
        rate[i] = rate[i+1]; // e descartar o valor IBI mais antigo
        runningTotal += rate[i]; // some os 9 valores IBI mais antigos
      }
      rate[9] = IBI; // adicione o IBI mais recente à matriz de taxas
      runningTotal += rate[9]; // adicione o IBI mais recente ao runningTotal
      runningTotal /= 10; // calcule a média dos últimos 10 valores IBI
      BPM = 60000/runningTotal; // quantas batidas cabem em um minuto? isso é BPM!
      QS = true; // definir sinalizador Quantified Self
      // QS FLAG NÃO ESTÁ APAGADA DENTRO DESTE ISR
      pulse = BPM;
    }
  }
  if (Signal < thresh && Pulse == true)
  { // quando os valores estão caindo, a batida acabou
    digitalWrite(blinkPin,LOW); // desligue o pino 13 LED
    Pulse = false; // redefina a bandeira do pulso para que possamos fazer de novo
    amp = P - T; // obter amplitude da onda de pulso
    thresh = amp/2 + T; // definir limite em 50% da amplitude
    P = thresh; // reinicie para a próxima vez
    T = thresh;
  }
  if (N > 2500)
  { // se 2,5 segundos passarem sem parar
    thresh = 512; // definir limite padrão
    P = 512; // definir P padrão
    T = 512; // definir T padrão
    lastBeatTime = sampleCounter; // traz o lastBeatTime atualizado
    firstBeat = true; // defina-os para evitar ruído
    secondBeat = false; // quando tivermos a pulsação de volta
  }
  sei(); // habilite interrupções quando terminar!
}// fim isr

void esp_8266()
{
  // conexão TCP AT+CIPSTART=4,"TCP","184.106.153.149",80
  String cmd = "AT+CIPSTART=4,\"TCP\",\"";
  cmd += "184.106.153.149"; // api.thingspeak.com
  cmd += "\",80";
  ser.println(cmd);
  Serial.println(cmd);
  if(ser.find("Error"))
  {
    Serial.println("AT+CIPSTART error");
    return;
  }
  String getStr = "GET /update?api_key=";
  getStr += apiKey;
  getStr +="&field1=";
  getStr +=String(temp);
  getStr +="&field2=";
  getStr +=String(pulse);
  getStr += "\r\n\r\n";
  // enviar comprimento de dados
  cmd = "AT+CIPSEND=4,";
  cmd += String(getStr.length());
  ser.println(cmd);
  Serial.println(cmd);
  delay(1000);
  ser.print(getStr);
  Serial.println(getStr); // Thingspeak precisa de 15 segundos de atraso entre as atualizações
  delay(3000);
}

void read_temp()
{
  int temp_val = analogRead(A1);
  float mv = (temp_val/1024.0)*5000;
  float cel = mv/10;
  temp = (cel*9)/5 + 32;
  Serial.print("Temperatura:");
  Serial.println(temp);
  lcd.clear();  
  lcd.setCursor(0,0);
  lcd.print("BPM :");  
  lcd.setCursor(7,0);
  lcd.print(BPM);
  lcd.setCursor(0,1);
  lcd.print("Temp.:");  
  lcd.setCursor(7,1); 
  lcd.print(temp);
  lcd.setCursor(13,1);  
  lcd.print("F");
}

Você pode verificar esta postagem também. Esta é uma versão melhor do Sistema de monitoramento da saúde do paciente na IoT. Verifique isto: Monitoramento da saúde do paciente baseado em IoT no servidor da Web ESP32

 

Visits: 2 Visits: 1191001