IoT Based Patient Health Monitoring

using ESP8266 & Arduino

https://how2electronics.com/iot-patient-health-monitoring-system-esp8266/

Table of Contents [hide]

 1 Patient Health Monitoring System using ESP8266 & Arduino:
 2 Block Diagram:
 3 Bill of Materials:
 4 Pulse Sensor:
 5 LM35 Temperature Sensor:
 6 ESP8266:
 7 Circuit Diagram & Connections:
 8 Setting the ThingSpeak:
 9 Source Code/Program:
 10 Video Tutorial & Explanation:
 11 Share & Spread Knowledge:
 12 Related

Patient Health Monitoring System using ESP8266 & Arduino:

With tons of new healthcare technology start-ups, IoT is rapidly revolutionizing
the healthcare industry. In this project, we have designed the IoT Based Patient
Health Monitoring System using ESP8266 & Arduino. The IoT platform used
in this project is ThingSpeak. ThingSpeak 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. This IoT device could read
the pulse rate and measure the surrounding temperature. It continuously
monitors the pulse rate and surrounding temperature and updates them to an IoT
platform.
The Arduino Sketch running over the device implements the various
functionalities of the project like reading sensor data, converting them into
strings, passing them to the IoT platform, and displaying measured pulse rate
and temperature on character LCD.

You can check our previous projects related to Pulse Sensor if you are a
beginner:
1. Heartbeat/Pulse/BPM Rate Monitor using Arduino & Pulse Sensor.
2. Pulse Rate Monitoring over Internet using ThingSpeak & ESP8266.
3. ECG Display using Pulse Sensor with OLED & Arduino.
Block Diagram:

This is a simple block diagram that explains the IoT Based Patient Health
Monitoring System using ESP8266 & Arduino. Pulse Sensor and LM35
Temperature Sensors measure BPM & Environmental Temperature respectively.
The Arduino processes the code and displays it to 16*2 LCD Display. ESP8266
Wi-Fi module connects to Wi-Fi and sends the data to IoT device server. The
IoT server used here is Thingspeak. Finally, the data can be monitored from any
part of the world by logging into the Thingspeak channel.

Pulse Sensor:
The Pulse Sensor is a plug-and-play heart-rate sensor for Arduino. It can be
used by students, artists, athletes, makers, and game & mobile developers who
want to easily incorporate live heart-rate data into their projects. The essence is
an integrated optical amplifying circuit and noise eliminating circuit sensor. Clip
the Pulse Sensor to your earlobe or fingertip and plug it into your Arduino, you
can ready to read heart rate. Also, it has an Arduino demo code that makes it
easy to use.
The pulse sensor has three pins: VCC, GND & Analog Pin.

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:

The LM35 series are precision integrated-circuit temperature devices with an
output voltage linearly-proportional to the Centigrade temperature. The LM35
device has an advantage over linear temperature sensors calibrated in Kelvin, as
the user is not required to subtract a large constant voltage from the output to
obtain convenient Centigrade scaling. The LM35 device does not require any
external calibration or trimming to provide typical accuracies of ±¼°C at room
temperature and ±¾°C over a full −55°C to 150°C temperature range.

ESP8266:
The ESP8266 is a very user-friendly and low-cost device to provide internet
connectivity to your projects. The module can work both as an Access point (can
create hotspot) and as a station (can connect to Wi-Fi), hence it can easily fetch
data and upload it to the internet making the Internet of Things as easy as
possible. It can also fetch data from the internet using API’s hence your project
could access any information that is available on the internet, thus making it
smarter. Another exciting feature of this module is that it can be programmed
using the Arduino IDE which makes it a lot more user friendly.

The ESP8266 module works with 3.3V only, anything more than 3.7V would kill
the module hence be cautions 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.

1. Connect Pulse Sensor output pin to A0 of Arduino and other two pins to VCC & GND.
2. Connect LM35 Temperature Sensor output pin to A1 of Arduino and other two pins to
VCC & GND.
3. Connect the LED to Digital Pin 7 of Arduino via a 220-ohm resistor.
4. Connect Pin 1,3,5,16 of LCD to GND.
5. Connect Pin 2,15 of LCD to VCC.
6. Connect Pin 4,6,11,12,13,14 of LCD to Digital Pin12,11,5,4,3,2 of Arduino.
 7. 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.
8. Connect the TX pin of the ESP8266 to pin 9 of the Arduino.

Setting the ThingSpeak:

ThingSpeak provides a very good tool for IoT based projects. By using the
ThingSpeak site, we can monitor our data and control our system over the
Internet, using the Channels and web pages provided by ThingSpeak. So first
you need to sign up for ThingSpeak. So visit https://thingspeak.com and create
an account.

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/Program:
The source code for the project IoT Based Patient Health Monitoring System
using ESP8266 & Arduino is given below. Simply copy the code and paste it to
your Arduino IDE, then compile it and upload it to your Arduino UNO Board.

1 #include <LiquidCrystal.h>

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

3 #include <SoftwareSerial.h>

4 float pulse = 0;

5 float temp = 0;

6 SoftwareSerial ser(9,10);

7 String apiKey = "OO707TGA1BLUNN12";

9 // Variables

10 int pulsePin = A0; // Pulse Sensor purple wire connected to analog pin 0

11 int blinkPin = 7 ; // pin to blink led at each beat

12 int fadePin = 13; // pin to do fancy classy fading blink at each beat

13 int fadeRate = 0; // used to fade LED on with PWM on fadePin

14

15 // Volatile Variables, used in the interrupt service routine!

16

17 volatile int BPM; // int that holds raw Analog in 0. updated every 2mS

18 volatile int Signal; // holds the incoming raw data

19 volatile int IBI = 600; // int that holds the time interval between beats! Must be seeded!

20 volatile boolean Pulse = false; // "True" when User's live heartbeat is detected. "False" when nota "live
beat".
21
volatile boolean QS = false; // becomes true when Arduoino finds a beat.
22

23
// Regards Serial OutPut -- Set This Up to your needs
24
static boolean serialVisual = true; // Set to 'false' by Default. Re-set to 'true' to see Arduino Serial
25 Monitor ASCII Visual Pulse

26 volatile int rate[10]; // array to hold last ten IBI values

27 volatile unsigned long sampleCounter = 0; // used to determine pulse timing

28 volatile unsigned long lastBeatTime = 0; // used to find IBI

29 volatile int P = 512; // used to find peak in pulse wave, seeded

30 volatile int T = 512; // used to find trough in pulse wave, seeded

31 volatile int thresh = 525; // used to find instant moment of heart beat, seeded

32 volatile int amp = 100; // used to hold amplitude of pulse waveform, seeded

33 volatile boolean firstBeat = true; // used to seed rate array so we startup with reasonable BPM

34 volatile boolean secondBeat = false; // used to seed rate array so we startup with reasonable BPM

35

36 void setup()

37 {

38 lcd.begin(16, 2);

39 pinMode(blinkPin,OUTPUT); // pin that will blink to your heartbeat!

40 pinMode(fadePin,OUTPUT); // pin that will fade to your heartbeat!

41 Serial.begin(115200); // we agree to talk fast!

42 interruptSetup(); // sets up to read Pulse Sensor signal every 2mS

43

44 // IF YOU ARE POWERING The Pulse Sensor AT VOLTAGE LESS THAN THE BOARD VOLTAGE,

45

46 // UN-COMMENT THE NEXT LINE AND APPLY THAT VOLTAGE TO THE A-REF PIN

47

48 // analogReference(EXTERNAL);

49

50 lcd.clear();

51 lcd.setCursor(0,0);

52 lcd.print(" Patient Health");

53 lcd.setCursor(0,1);

54 lcd.print(" Monitoring ");

55 delay(4000);

56 lcd.clear();

57 lcd.setCursor(0,0);

58 lcd.print("Initializing....");

59 delay(5000);

60 lcd.clear();

61 lcd.setCursor(0,0);
62 lcd.print("Getting Data....");

63 ser.begin(9600);

64 ser.println("AT");

65 delay(1000);

66 ser.println("AT+GMR");

67 delay(1000);

68 ser.println("AT+CWMODE=3");

69 delay(1000);

70 ser.println("AT+RST");

71 delay(5000);

72 ser.println("AT+CIPMUX=1");

73 delay(1000);

74

75 String cmd="AT+CWJAP=\"Alexahome\",\"98765432\"";

76 ser.println(cmd);

77 delay(1000);

78 ser.println("AT+CIFSR");

79 delay(1000);

80 }

81

82 // Where the Magic Happens

83 void loop()

84 {

85 serialOutput();

86 if (QS == true) // A Heartbeat Was Found

87 {

88

89 // BPM and IBI have been Determined

90 // Quantified Self "QS" true when arduino finds a heartbeat

91 fadeRate = 255; // Makes the LED Fade Effect Happen, Set 'fadeRate' Variable to 255 to fade LED with
pulse
92
serialOutputWhenBeatHappens(); // A Beat Happened, Output that to serial.
93
QS = false; // reset the Quantified Self flag for next time
94
95 }

96 ledFadeToBeat(); // Makes the LED Fade Effect Happen

97 delay(20); // take a break

98 read_temp();

99 esp_8266();

100 }

101 void ledFadeToBeat()

102 {

103 fadeRate -= 15; // set LED fade value

104 fadeRate = constrain(fadeRate,0,255); // keep LED fade value from going into negative numbers!

105 analogWrite(fadePin,fadeRate); // fade LED

106 }

107 void interruptSetup()

108 {

109 // Initializes Timer2 to throw an interrupt every 2mS.

110 TCCR2A = 0x02; // DISABLE PWM ON DIGITAL PINS 3 AND 11, AND GO INTO CTC MODE

111 TCCR2B = 0x06; // DON'T FORCE COMPARE, 256 PRESCALER

112 OCR2A = 0X7C; // SET THE TOP OF THE COUNT TO 124 FOR 500Hz SAMPLE RATE

113 TIMSK2 = 0x02; // ENABLE INTERRUPT ON MATCH BETWEEN TIMER2 AND OCR2A

114 sei(); // MAKE SURE GLOBAL INTERRUPTS ARE ENABLED

115 }

116 void serialOutput()

117 { // Decide How To Output Serial.

118 if (serialVisual == true)

119 {

120 arduinoSerialMonitorVisual('-', Signal); // goes to function that makes Serial Monitor Visualizer

121 }

122 else

123 {

124 sendDataToSerial('S', Signal); // goes to sendDataToSerial function

125 }

126 }

127 void serialOutputWhenBeatHappens()

128 {

129 if (serialVisual == true) // Code to Make the Serial Monitor Visualizer Work

130 {

131 Serial.print("*** Heart-Beat Happened *** "); //ASCII Art Madness

132 Serial.print("BPM: ");

133 Serial.println(BPM);

134 }

135 else

136 {

137 sendDataToSerial('B',BPM); // send heart rate with a 'B' prefix

138 sendDataToSerial('Q',IBI); // send time between beats with a 'Q' prefix

139 }

140 }

141 void arduinoSerialMonitorVisual(char symbol, int data )

142 {

143 const int sensorMin = 0; // sensor minimum, discovered through experiment

144 const int sensorMax = 1024; // sensor maximum, discovered through experiment

145 int sensorReading = data; // map the sensor range to a range of 12 options:

146 int range = map(sensorReading, sensorMin, sensorMax, 0, 11);

147 // do something different depending on the

148 // range value:

149 switch (range)

150 {

151 case 0:

152 Serial.println(""); /////ASCII Art Madness

153 break;

154 case 1:

155 Serial.println("---");

156 break;

157 case 2:

158 Serial.println("------");

159 break;

160 case 3:
161 Serial.println("---------");

162 break;

163 case 4:

164 Serial.println("------------");

165 break;

166 case 5:

167 Serial.println("--------------|-");

168 break;

169 case 6:

170 Serial.println("--------------|---");

171 break;

172 case 7:

173 Serial.println("--------------|-------");

174 break;

175 case 8:

176 Serial.println("--------------|----------");

177 break;

178 case 9:

179 Serial.println("--------------|----------------");

180 break;

181 case 10:

182 Serial.println("--------------|-------------------");

183 break;

184 case 11:

185 Serial.println("--------------|-----------------------");

186 break;

187 }

188 }

189

190 void sendDataToSerial(char symbol, int data )

191 {

192 Serial.print(symbol);

193 Serial.println(data);
194 }

195 ISR(TIMER2_COMPA_vect) //triggered when Timer2 counts to 124

196 {

197 cli(); // disable interrupts while we do this

198 Signal = analogRead(pulsePin); // read the Pulse Sensor

199 sampleCounter += 2; // keep track of the time in mS with this variable

200 int N = sampleCounter - lastBeatTime; // monitor the time since the last beat to avoid noise

201 // find the peak and trough of the pulse wave

202

203 if(Signal < thresh && N > (IBI/5)*3) // avoid dichrotic noise by waiting 3/5 of last IBI

204 {

205 if (Signal < T) // T is the trough

206 {

207 T = Signal; // keep track of lowest point in pulse wave

208 }

209 }

210 if(Signal > thresh && Signal > P)

211 { // thresh condition helps avoid noise

212 P = Signal; // P is the peak

213 } // keep track of highest point in pulse wave

214 // NOW IT'S TIME TO LOOK FOR THE HEART BEAT

215 // signal surges up in value every time there is a pulse

216 if (N > 250)

217 { // avoid high frequency noise

218 if ( (Signal > thresh) && (Pulse == false) && (N > (IBI/5)*3) )

219 {

220 Pulse = true; // set the Pulse flag when we think there is a pulse

221 digitalWrite(blinkPin,HIGH); // turn on pin 13 LED

222 IBI = sampleCounter - lastBeatTime; // measure time between beats in mS

223 lastBeatTime = sampleCounter; // keep track of time for next pulse

224

225 if(secondBeat)

226 { // if this is the second beat, if secondBeat == TRUE

227 secondBeat = false; // clear secondBeat flag

228 for(int i=0; i<=9; i++) // seed the running total to get a realisitic BPM at startup

229 {

230 rate[i] = IBI;

231 }

232 }

233 if(firstBeat) // if it's the first time we found a beat, if firstBeat == TRUE

234 {

235 firstBeat = false; // clear firstBeat flag

236 secondBeat = true; // set the second beat flag

237 sei(); // enable interrupts again

238 return; // IBI value is unreliable so discard it

239 }

240 // keep a running total of the last 10 IBI values

241 word runningTotal = 0; // clear the runningTotal variable

242 for(int i=0; i<=8; i++)

243 { // shift data in the rate array

244 rate[i] = rate[i+1]; // and drop the oldest IBI value

245 runningTotal += rate[i]; // add up the 9 oldest IBI values

246 }

247 rate[9] = IBI; // add the latest IBI to the rate array

248 runningTotal += rate[9]; // add the latest IBI to runningTotal

249 runningTotal /= 10; // average the last 10 IBI values

250 BPM = 60000/runningTotal; // how many beats can fit into a minute? that's BPM!

251 QS = true; // set Quantified Self flag

252 // QS FLAG IS NOT CLEARED INSIDE THIS ISR

253 pulse = BPM;

254 }

255 }

256 if (Signal < thresh && Pulse == true)

257 { // when the values are going down, the beat is over

258 digitalWrite(blinkPin,LOW); // turn off pin 13 LED

259 Pulse = false; // reset the Pulse flag so we can do it again

260 amp = P - T; // get amplitude of the pulse wave

261 thresh = amp/2 + T; // set thresh at 50% of the amplitude

262 P = thresh; // reset these for next time

263 T = thresh;

264 }

265 if (N > 2500)

266 { // if 2.5 seconds go by without a beat

267 thresh = 512; // set thresh default

268 P = 512; // set P default

269 T = 512; // set T default

270 lastBeatTime = sampleCounter; // bring the lastBeatTime up to date

271 firstBeat = true; // set these to avoid noise

272 secondBeat = false; // when we get the heartbeat back

273 }

274 sei(); // enable interrupts when youre done!

275 }// end isr

276 void esp_8266()

277 {

278 // TCP connection AT+CIPSTART=4,"TCP","184.106.153.149",80

279 String cmd = "AT+CIPSTART=4,\"TCP\",\"";

280 cmd += "184.106.153.149"; // api.thingspeak.com

281 cmd += "\",80";

282 ser.println(cmd);

283 Serial.println(cmd);

284 if(ser.find("Error"))

285 {

286 Serial.println("AT+CIPSTART error");

287 return;

288 }

289 String getStr = "GET /update?api_key=";

290 getStr += apiKey;

291 getStr +="&field1=";

292 getStr +=String(temp);

 getStr +="&field2=";

293 getStr +=String(pulse);

294 getStr += "\r\n\r\n";

295 // send data length

296 cmd = "AT+CIPSEND=4,";

297 cmd += String(getStr.length());

298 ser.println(cmd);

299 Serial.println(cmd);

300 delay(1000);

301 ser.print(getStr);

302 Serial.println(getStr); //thingspeak needs 15 sec delay between updates

303 delay(3000);

304 }

305 void read_temp()

306 {

307 int temp_val = analogRead(A1);

308 float mv = (temp_val/1024.0)*5000;

309 float cel = mv/10;

310 temp = (cel*9)/5 + 32;

311 Serial.print("Temperature:");

312 Serial.println(temp);

313 lcd.clear();

314 lcd.setCursor(0,0);

315 lcd.print("BPM :");

316 lcd.setCursor(7,0);

317 lcd.print(BPM);

318 lcd.setCursor(0,1);

319 lcd.print("Temp.:");

320 lcd.setCursor(7,1);

321 lcd.print(temp);

322 lcd.setCursor(13,1);

323 lcd.print("F");