IOT based Patient Health Monitoring using ESP8266 & Arduino

Introduction

In today’s world, health monitoring is a major issue. Patients suffer from serious health problems as a result of a lack of proper health monitoring. There are many IoT devices available these days to monitor a patient’s health over the internet. Health professionals are also using these smart devices to keep tabs on their patients. IoT is rapidly revolutionizing the healthcare industry, with hundreds of new healthcare technology start-ups using patient health monitoring system

In this project, we will create an IOT-based Health Monitoring System that will record the patient’s pulse rate and surrounding temperature. This system not only record these data but also update them in IOT platform. The IOT platform used in this project is Thing Speak. Thing Speak is an open-source Internet of Things (IoT) application and API to store and retrieve data from things using the HTTP protocol over the Internet or via a Local Area Network.

We have already done some similar projects you can view them by clicking the following link

IOT BASED PARALYZED HEALTH CARE MONITORING AND FACILITATION

Bill Of Material

Arduino Nano Board microcontroller https://amzn.to/3EBaQFT

LCD Display 16x2 LCD Display https://amzn.to/3hXYRdV

Potentiometer 10K https://amzn.to/3tX7vMD

ESP8266-01 Wifi Module https://amzn.to/3EwkTfD

Pulse Sensor PulseSensorhttps://amzn.to/3OAxxPb

LM35 Temperature Sensor https://amzn.to/3XvVaN2

Connecting wires jumper wire some https://amzn.to/3tX7PLl

Breadboard Normal https://amzn.to/3Vlefzw

2K Resistor THT https://amzn.to/3EudLQO

1K Resistor THT https://amzn.to/3V5Yblo

LED 5mm Any Color https://amzn.to/3AHaTih

Block Diagram

This is a simple block diagram demonstrating the IoT Based Patient Health Monitoring System with ESP8266 and Arduino. BPM and environmental temperature are measured by the pulse sensor and the LM35 temperature sensor, respectively. The code is processed by the Arduino and displayed on a 16*2 LCD display. The ESP8266 Wi-Fi module connects to the internet and sends data to an IoT device server. The IoT server used here is Thing speak. Finally, the data can be accessed from anywhere in the world by connecting to the Thing speak channel.

📷Block diagram of Patient Health Monitoring Based On IOT using ESP8266 & Arduino

What is a Pulse sensor?

📷Pulse sensor

A pulse wave is the change in the volume of a blood vessel that occurs when the heart pumps blood, and a detector that monitors this volume change is called a pulse sensor. The Pulse Sensor is an Arduino-compatible heart-rate sensor. Students, artists, athletes, makers, game and mobile developers who want to easily incorporate live heart-rate data into their projects can use it. It essentially combines a basic optical heart rate sensor with amplification and noise cancellation circuitry, allowing for quick and easy pulse readings.

Pulse sensor top and back view

There is also a LED in the center of this sensor module which helps in detecting the heartbeat. Below the LED, there is a noise elimination circuitry that is supposed to keep away the noise from affecting the readings.

LM35 Temperature Sensor:

LM35 is a temperature sensor that outputs an analog signal which is proportional to the instantaneous temperature. The output voltage can easily be interpreted to obtain a temperature reading in Celsius. The advantage of lm35 over thermistor is it does not require any external calibration. The coating also protects it from self-heating.

📷LM35 Temperature Sensor:

ESP8266

The ESP8266 is a simple and inexpensive device for providing internet connectivity to your projects. Because the module can function as both an access point (which can create a hotspot) and a station (which can connect to Wi-Fi), it can easily fetch data and upload it to the internet, making the Internet of Things as simple as possible. It can also retrieve data from the internet via APIs, allowing your project to access any information available on the internet, making it smarter. Another intriguing feature of this module is that it can be programmed using the Arduino IDE, making it much more user-friendly.

📷ESP8266 pin diagram

Pin 1: Ground: Connected to the ground of the circuitPin 2: Tx/GPIO – 1: Connected to Rx pin of programmer/uC to upload programPin 3: GPIO – 2: General purpose Input/output pinPin 4 : CH_EN: Chip Enable/Active highPin 5: Flash/GPIO – 0: General purpose Input/output pinPin 6 : Reset: Resets the modulePin 7: RX/GPIO – 3: General purpose Input/output pinPin 8: Vcc: Connect to +3.3V only

Circuit Diagram

The circuit diagram of IOT based Patient Health Monitoring system is shown in the figure below. If you are doing the same project then assemble the circuit as shown in the figure below:

📷CIrcuit Diagram Of Patient Health Monitoring Based On IOT

• Connect Pulse Sensor output pin to A0 of Arduino and other two pins to VCC & GND.
• Connect LM35 Temperature Sensor output pin to A1 of Arduino and other two pins to VCC & GND.
• Connect the LED to Digital Pin 7 of Arduino via a 220-ohm resistor.
• Connect Pin 1, 3, 5, 16 of LCD to GND.
• Connect Pin 2, 15 of LCD to VCC.
• Connect Pin 4, 6, 11, 12, 13, 14 of LCD to Digital Pin12, 11, 5, 4, 3, 2 of Arduino.
• The RX pin of ESP8266 works on 3.3V and it will not communicate with the Arduino when we will connect it directly to the Arduino. So, we will have to make a voltage divider for it which will convert the 5V into 3.3V. This can be done by connecting the 2.2K & 1K resistor. Thus the RX pin of the ESP8266 is connected to pin 10 of Arduino through the resistors.
• Connect the TX pin of the ESP8266 to pin 9 of the Arduino.

Here is another version of the Schematic designed using EasyEDA software. Instead of using Arduino UNO, you can use Arduino Nano for this project.

📷Schematic of IOT based Patient Health Monitoring system

PCB Manufacturer

PCBWAY is quite professional in the field of PCB manufacturing; you can try their services at extremely low prices, Only 5 dollars for 10 PCBs, besides this the new members also get a 5 Dollars bonus.

You can now upload the Gerber File to the Website and place an order. The PCB quality is superb & high standard. That is why most of people trust PCBWAY for PCB & PCBA Services.

You Will get FREE prototype pcb from PCBWAY. So do not be late to register and place your first order fromPCBWAY

If you want to order pcb from PCBWAY. CLICK IN THE LINK BELOW:

Some Sample PCB ‘ S From PCBWAY

📷

📷

📷

📷

📷

Manufacturing Files

If you don’t want to assemble the circuit on breadboard and you want PCB for the project, then here is the PCB for you.

📷Top side pcb

📷Bottom side

Gerber Files

Download gerber files

Gerber_PCB_Patient-Health-MonitoringDownload

Setting Up Thingspeak

ThingSpeak provides very good tools for IoT-based projects. The ThingSpeak websiteallowsyouto monitor data and control your system over the Internet using channels and web pages provided by ThingSpeak. Therefore,youmust first loginto ThingSpeak. Pleaseaccesshttps:Create an accountatthingspeak.com.

Then create a new channel and set up what you want. The tutorial in the video below. Follow the video for more clarification.

Then create the API keys. This key is required for programming modifications and setting your data.

Then upload the code to the Arduino UNO by assembling the circuit shown above. Open the serial monitor and it will automatically connect to Wi-Fi and set up everything.

Now click on channels so that you can see the online data streaming, i.e IoT Based Patient Health Monitoring System using ESP8266 & Arduino as shown in the figure here.

Source Code

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
#include <SoftwareSerial.h>
float pulse = 0;
float temp = 0;
SoftwareSerial ser(9,10);
String apiKey = "OO707TGA1BLUNN12";
  
// Variables
int pulsePin = A0; // Pulse Sensor purple wire connected to analog pin 0
int blinkPin = 7 ; // pin to blink led at each beat
int fadePin = 13; // pin to do fancy classy fading blink at each beat
int fadeRate = 0; // used to fade LED on with PWM on fadePin
  
// Volatile Variables, used in the interrupt service routine!
  
volatile int BPM; // int that holds raw Analog in 0. updated every 2mS
volatile int Signal; // holds the incoming raw data
volatile int IBI = 600; // int that holds the time interval between beats! Must be seeded!
volatile boolean Pulse = false; // "True" when User's live heartbeat is detected. "False" when nota "live beat".
volatile boolean QS = false; // becomes true when Arduoino finds a beat.
  
// Regards Serial OutPut -- Set This Up to your needs
static boolean serialVisual = true; // Set to 'false' by Default. Re-set to 'true' to see Arduino Serial Monitor ASCII Visual Pulse
volatile int rate[10]; // array to hold last ten IBI values
volatile unsigned long sampleCounter = 0; // used to determine pulse timing
volatile unsigned long lastBeatTime = 0; // used to find IBI
volatile int P = 512; // used to find peak in pulse wave, seeded
volatile int T = 512; // used to find trough in pulse wave, seeded
volatile int thresh = 525; // used to find instant moment of heart beat, seeded
volatile int amp = 100; // used to hold amplitude of pulse waveform, seeded
volatile boolean firstBeat = true; // used to seed rate array so we startup with reasonable BPM
volatile boolean secondBeat = false; // used to seed rate array so we startup with reasonable BPM
  
void setup()
{
lcd.begin(16, 2);
pinMode(blinkPin,OUTPUT); // pin that will blink to your heartbeat!
pinMode(fadePin,OUTPUT); // pin that will fade to your heartbeat!
Serial.begin(115200); // we agree to talk fast!
interruptSetup(); // sets up to read Pulse Sensor signal every 2mS
  
// IF YOU ARE POWERING The Pulse Sensor AT VOLTAGE LESS THAN THE BOARD VOLTAGE,
  
// UN-COMMENT THE NEXT LINE AND APPLY THAT VOLTAGE TO THE A-REF PIN
  
// analogReference(EXTERNAL);
  
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" Patient Health");
lcd.setCursor(0,1);
lcd.print(" Monitoring ");
delay(4000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Initializing....");
delay(5000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Getting Data....");
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);
}
  
// Where the Magic Happens
void loop()
{
serialOutput();
if (QS == true) // A Heartbeat Was Found
{
  
// BPM and IBI have been Determined
// Quantified Self "QS" true when arduino finds a heartbeat
fadeRate = 255; // Makes the LED Fade Effect Happen, Set 'fadeRate' Variable to 255 to fade LED with pulse
serialOutputWhenBeatHappens(); // A Beat Happened, Output that to serial.
QS = false; // reset the Quantified Self flag for next time
}
ledFadeToBeat(); // Makes the LED Fade Effect Happen
delay(20); // take a break
read_temp();
esp_8266();
}
void ledFadeToBeat()
{
fadeRate -= 15; // set LED fade value
fadeRate = constrain(fadeRate,0,255); // keep LED fade value from going into negative numbers!
analogWrite(fadePin,fadeRate); // fade LED
}
void interruptSetup()
{
// Initializes Timer2 to throw an interrupt every 2mS.
TCCR2A = 0x02; // DISABLE PWM ON DIGITAL PINS 3 AND 11, AND GO INTO CTC MODE
TCCR2B = 0x06; // DON'T FORCE COMPARE, 256 PRESCALER
OCR2A = 0X7C; // SET THE TOP OF THE COUNT TO 124 FOR 500Hz SAMPLE RATE
TIMSK2 = 0x02; // ENABLE INTERRUPT ON MATCH BETWEEN TIMER2 AND OCR2A
sei(); // MAKE SURE GLOBAL INTERRUPTS ARE ENABLED
}
void serialOutput()
{ // Decide How To Output Serial.
if (serialVisual == true)
{
arduinoSerialMonitorVisual('-', Signal); // goes to function that makes Serial Monitor Visualizer
}
else
{
sendDataToSerial('S', Signal); // goes to sendDataToSerial function
}
}
void serialOutputWhenBeatHappens()
{
if (serialVisual == true) // Code to Make the Serial Monitor Visualizer Work
{
Serial.print("*** Heart-Beat Happened *** "); //ASCII Art Madness
Serial.print("BPM: ");
Serial.println(BPM);
}
else
{
sendDataToSerial('B',BPM); // send heart rate with a 'B' prefix
sendDataToSerial('Q',IBI); // send time between beats with a 'Q' prefix
}
}
void arduinoSerialMonitorVisual(char symbol, int data )
{
const int sensorMin = 0; // sensor minimum, discovered through experiment
const int sensorMax = 1024; // sensor maximum, discovered through experiment
int sensorReading = data; // map the sensor range to a range of 12 options:
int range = map(sensorReading, sensorMin, sensorMax, 0, 11);
// do something different depending on the
// range value:
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) //triggered when Timer2 counts to 124
{
cli(); // disable interrupts while we do this
Signal = analogRead(pulsePin); // read the Pulse Sensor
sampleCounter += 2; // keep track of the time in mS with this variable
int N = sampleCounter - lastBeatTime; // monitor the time since the last beat to avoid noise
// find the peak and trough of the pulse wave
  
if(Signal < thresh && N > (IBI/5)*3) // avoid dichrotic noise by waiting 3/5 of last IBI
{
if (Signal < T) // T is the trough
{
T = Signal; // keep track of lowest point in pulse wave
}
}
if(Signal > thresh && Signal > P)
{ // thresh condition helps avoid noise
P = Signal; // P is the peak
} // keep track of highest point in pulse wave
// NOW IT'S TIME TO LOOK FOR THE HEART BEAT
// signal surges up in value every time there is a pulse
if (N > 250)
{ // avoid high frequency noise
if ( (Signal > thresh) && (Pulse == false) && (N > (IBI/5)*3) )
{
Pulse = true; // set the Pulse flag when we think there is a pulse
digitalWrite(blinkPin,HIGH); // turn on pin 13 LED
IBI = sampleCounter - lastBeatTime; // measure time between beats in mS
lastBeatTime = sampleCounter; // keep track of time for next pulse
  
if(secondBeat)
{ // if this is the second beat, if 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) // if it's the first time we found a beat, if firstBeat == TRUE
{
firstBeat = false; // clear firstBeat flag
secondBeat = true; // set the second beat flag
sei(); // enable interrupts again
return; // IBI value is unreliable so discard it
}
// keep a running total of the last 10 IBI values
word runningTotal = 0; // clear the runningTotal variable
for(int i=0; i<=8; i++)
{ // shift data in the rate array
rate[i] = rate[i+1]; // and drop the oldest IBI value
runningTotal += rate[i]; // add up the 9 oldest IBI values
}
rate[9] = IBI; // add the latest IBI to the rate array
runningTotal += rate[9]; // add the latest IBI to runningTotal
runningTotal /= 10; // average the last 10 IBI values
BPM = 60000/runningTotal; // how many beats can fit into a minute? that's BPM!
QS = true; // set Quantified Self flag
// QS FLAG IS NOT CLEARED INSIDE THIS ISR
pulse = BPM;
}
}
if (Signal < thresh && Pulse == true)
{ // when the values are going down, the beat is over
digitalWrite(blinkPin,LOW); // turn off pin 13 LED
Pulse = false; // reset the Pulse flag so we can do it again
amp = P - T; // get amplitude of the pulse wave
thresh = amp/2 + T; // set thresh at 50% of the amplitude
P = thresh; // reset these for next time
T = thresh;
}
if (N > 2500)
{ // if 2.5 seconds go by without a beat
thresh = 512; // set thresh default
P = 512; // set P default
T = 512; // set T default
lastBeatTime = sampleCounter; // bring the lastBeatTime up to date
firstBeat = true; // set these to avoid noise
secondBeat = false; // when we get the heartbeat back
}
sei(); // enable interrupts when youre done!
}// end isr
void esp_8266()
{
// TCP connection 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";
// send data length
cmd = "AT+CIPSEND=4,";
cmd += String(getStr.length());
ser.println(cmd);
Serial.println(cmd);
delay(1000);
ser.print(getStr);
Serial.println(getStr); //thingspeak needs 15 sec delay between updates
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("Temperature:");
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");
}

Youtube

https://www.youtube.com/watch?v=2zK0O5UhHoE

Full Project On website:

https://electronicsworkshops.com/2022/11/14/patient-health-monitoring-using-esp8266-arduino/