Monitoramento da saúde do paciente baseado em IoT usando ESP8266 e Arduino
Conteudo
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.
- Conecte o pino de saída do sensor de pulso a A0 do Arduino e outros dois pinos a VCC e GND.
- Conecte o pino de saída do sensor de temperatura LM35 a A1 do Arduino e outros dois pinos a VCC e GND.
- Conecte o LED ao pino digital 7 do Arduino por meio de um resistor de 220 ohms.
- Conecte o pino 1,3,5,16 do LCD ao GND.
- Conecte o pino 2,15 do LCD ao VCC.
- Conecte o pino 4,6,11,12,13,14 do LCD ao pino digital 12,11,5,4,3,2 do Arduino.
- 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.
- 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
![Eletrônica Passo a Passo [Coleção Completa]](https://capsistema.com.br/wp-content/uploads/2020/08/foto1-5-150x150.png "Eletrônica Passo a Passo [Coleção Completa]")
