IOT

IoT Based Patient Health Monitoring using ESP8266 & Arduino

IoT or the internet of things is characterized as a forthcoming innovation that empowers us to create worldwide networked machines and also the devices that can be helped for exchanging of communication. As we all know that the real-time application has been increasing day by day, and the smart connection also had increased.

 Rapid population growth, led to the increase in global life expectancy and the advance in technology, paving the pathway for the creation of age-friendly environments. This had led to the necessity in designing new products for elderly people’s healthcare. It is quite important to monitor various health parameters of patients.

Proposed System

We used ESP8266 and Arduino to create an IoT-based Patient Health Monitoring System for this project. ThingSpeak is the IoT platform used in this project. ThingSpeak is an open-source Internet of Items (IoT) application and API for storing and retrieving data from things via the Internet or a Local Area Network using the HTTP protocol. This IoT device may measure the temperature and read the heart rate. It continuously measures the pulse rate and temperature of the environment and sends data to an IoT platform.

The Arduino Sketch that runs on the device executes the project’s numerous functionalities, such as reading sensor data, converting it to strings, sending it to the IoT platform, and displaying the observed pulse rate and temperature on a character LCD.

Materials required

  • Arduino Uno and Programming Cable
  • ESP8266 Wi-Fi module
  • LM35 temperature sensor
  • Pulse rate sensor
  • Push-button
  • 10k Resistor
  • Male-female wires
  • Breadboard

Need For Health Monitoring System:

Here are the major benefits of a health monitoring system and the great reasons to develop it for your hospital to transform it into a Smart Hospital.

  • Real-time health monitoring systems using IoT can help doctors prioritize patients, and provide urgent care to those who are in the most danger thereby saving lives. 
  • More competent patient management can help utilize the resources of the hospital more wisely and save money.
  • It is easy to use the system for patients and medical professionals.
  • The remote health monitoring system is especially useful to monitor patients with chronic diseases. Most chronic diseases are incurable, so it is necessary to monitor the state of the patient while at home, and quickly respond if health indicators worsen.
  • The HMS is convenient and portable so it is very convenient for doctors to manage patients from one app, and it is also very easy for patients to monitor their own health by wearing a lightweight device like a bracelet.

Block Diagram:

IoT Based Patient Health Monitoring System using ESP8266 & Arduino

The IoT Based Patient Health Monitoring System utilizing ESP8266 & Arduino is explained in this simple block diagram. BPM is measured by the Pulse Sensor, and environmental temperature is measured by the LM35 Temperature Sensor. The code is processed by the Arduino and displayed on a 16*2 LCD display. The ESP8266 Wi-Fi module connects to Wi-Fi and transfers data to a server for IoT devices. Thingspeak is the IoT server in use here. Finally, by logging into the Thingspeak channel from anywhere in the world, the data may be monitored.

Pulse Sensor:

The Pulse Sensor is an Arduino-compatible heart-rate sensor. Students, artists, athletes, makers, and game and mobile developers who wish to incorporate live heart-rate data into their work can use it. An integrated optical amplification circuit and a noise-reducing circuit sensor are at the heart of the system. You may now read heart rate by clipping the Pulse Sensor to your earlobe or fingertip and plugging it into your Arduino. It also comes with an Arduino demo code, making it simple to use.

This sensor module also has an LED in the centre that aids in the detection of heartbeats. A noise elimination circuitry is located beneath the LED and is designed to keep noise from altering the readings.

The pulse sensor has three pins which are as described below:

  • Pin-1: GND: Black Colour Wire – Connected to the GND terminal
  • Pin-2: VCC: Red Colour Wire – Connected to the supply voltage ( +5V otherwise +3.3V)
  • Pin-3: Signal: Purple Colour Wire – Connected to the pulsating o/p signal.

LM35 Temperature Sensor:

The LM35 series are precision integrated-circuit temperature devices having a linearly proportional output voltage to the temperature in degrees Celsius. In comparison to linear temperature sensors calibrated in Kelvin, the LM35 device has the advantage of not requiring the user to subtract a large constant voltage from the output to obtain convenient Centigrade scaling. The LM35 gadget requires no external calibration or trimming to achieve typical accuracies of 14°C at ambient temperature and 34°C throughout a temperature range of 55°C to 150°C.

IoT Based Patient Health Monitoring System using ESP8266 & Arduino

ESP8266:

The ESP8266 is a low-cost, user-friendly gadget for connecting your creations to the internet. Because the module can function as both an access point (creating a hotspot) and a station (connecting to Wi-Fi), it can quickly retrieve data and post it to the internet, making the Internet of Things as simple as feasible. It can also use APIs to retrieve data from the internet, allowing your project to access any information that is available on the internet and so become wiser. Another appealing feature of this module is that it can be programmed using the Arduino IDE, making it much more accessible.

IoT Based Patient Health Monitoring System using ESP8266 & Arduino

The ESP8266 module works with 3.3V only, anything more than 3.7V would kill the module hence be cautious with your circuits. Here is its pins description.

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

Circuit Diagram & Connections:

For designing IoT Based Patient Health Monitoring System using ESP8266 & Arduino, assemble the circuit as shown in the figure below.

IoT Based Patient Health Monitoring System Circuit Diagram
  1. Connect the output pin of the pulse sensor to Arduino pin A0, and the other two pins to VCC and GND.
  2. Connect the output pin of the LM35 Temperature Sensor to Arduino pin A1 and the other two pins to VCC and GND.
  3. Using a 220-ohm resistor, connect the LED to Arduino’s Digital Pin 7.
  4. Connect the LCD Pins 1,3,5,16 to GND.
  5. Connect LCD Pin 2,15 to VCC.
  6. Connect LCD Pins 4,6,11,12,13,14 to Arduino Digital Pins 12,11,5,4,3,2.
  7. The RX pin of ESP8266 works on 3.3V and it will not communicate. When we attach it straight to the Arduino, it will work. As a result, we’ll need to create a voltage divider to convert the 5V to 3.3V. Connect the 2.2K and 1K resistors to do this. Through the resistors, the RX pin of the ESP8266 is connected to pin 10 of the Arduino.
  8. Connect the ESP8266’s TX pin to the Arduino’s pin 9.

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 Patient Health Monitoring

Schematics, PCB & Gerber File + PCB Ordering Online

If you don’t want to put the circuit together on a breadboard and instead want a PCB for your project, here is the PCB for you. EasyEDA‘s online Circuit Schematics & PCB Design tool was used to create the project’s PCB Board. The PCB’s front and back sides are shown below.

Fig: PCB Top SectionFig: PCB Bottom Section

Download Gerber File: Patient Health Monitoring Project

Now you can visit the PCBgogo official website by clicking here: https://www.pcbgogo.com/. So you will be directed to the PCBgogo website. Register now to get 50$ coupon for new users

You can now upload the Gerber File to the Website and place an order. The PCB quality is of top class and brilliant. That is why most people trust PCBgogo for PCB & PCBA Services.

Setting the ThingSpeak:

ThingSpeak is an excellent tool for IoT-related applications. We may use the ThingSpeak site to monitor and control our system via the Internet by using the Channels and web pages that ThingSpeak provides. To begin, you must first sign up for ThingSpeak.So visit https://thingspeak.com and create an account.

Thingspeak setup

Then make a new channel and configure it to your desire. The video below has an instruction. For additional information, watch the video.

After that, make the API keys. This key is necessary for programming changes and data settings.

Thingspeak setup

Then, using the circuit illustrated above, upload the code to the Arduino UNO. When you open the serial monitor, it will connect to Wi-Fi and set up everything for you.

Now, as indicated in the figure here, click on channels to observe the online data streaming, i.e. IoT Based Patient Health Monitoring System utilizing ESP8266 & Arduino.

Thingspeak setup
IoT Based Patient Health Monitoring System using ESP8266 & Arduino

Source Code/Program:

Below is the source code for the project IoT Based Patient Health Monitoring System with ESP8266 and Arduino. Simply copy and paste the code into your Arduino IDE, compile it, and upload it to your Arduino UNO.

#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”);
}

Conclusion:

I hope all of you understand how to design an IoT-based patient monitoring system. This is one of the interesting IoT project ideas to create. This real-time health monitoring system is a highly efficient and cost-effective method used for the complete care of elderly people as well as patients. The doctors can then provide patients with immediate solutions and guidance based on their health conditions.

We MATHA ELECTRONICS will be back soon with more informative blogs.

Leave a Reply

Your email address will not be published.