Designing a Small Health Monitoring System for the Elderly - HMS Blog #4 - Measuring Blood Pressure

14 Nov 2022

Measuring blood pressure

1. Introduction
2. How do we measure blood pressure?
3. Choosing a sensor
4. Experimenting with the sensor
5. Data
- Data logging
- Data plotting
6. Measuring blood pressure
- Measurement 1 - 120/79/79
- Measurement 2 - 105/68/68
7. Summary

1. Introduction

Hi! This will be my fourth blog for the Summer of Sensors Design Challenge. In the last blog (HMS Blog #3 - First Prototype) I finally worked with some hardware for this competition and got the first prototype working. This blog will be a bit different compared to my previous blogs for this Design Challenge, specifically in 2 ways. First off, this blog won't follow up where I left off in the last blog, but will rather take a completely different path. As you can tell from the title of this blog, this blog will focus on trying to measure blood pressure using a sensor. The other way this blog will be different is how I write it. I usually finish everything I have for the blog before I start writing it, or at least get far enough along that I know that everything should work in the end. This time, I'm starting with writing this blog in the middle of experimentation not knowing if this will yield good results or not. I think it's important (and fun!) to show the whole process, both good and bad. So, I hope I'll have it figured out by the end of this blog, but we'll see! Hope you enjoy reading the blog!

2. How do we measure blood pressure?

Measuring blood pressure is something that a lot of people need to do on a daily basis to keep in check, like my grandma, which is the reason for me trying to play with a sensor that can do that. The classical method for measuring blood pressure requires only a stethoscope and an arm cuff hooked up to a manometer to get a reading. The digital blood pressure monitors are in a similar fashion, but rather than using sound from the stethoscope, they use pressure sensors.

Here is a short explanation of how blood pressure is measured. The arm cuff is pumped full of air, cutting off the circulation in the brachial artery. The brachial artery is the artery that is going down the inside side of your biceps on your upper arm, and after the elbow, it splits into the radial and ulnar arteries. By pumping the arm cuff, we cut off the circulation in the brachial artery, once the device does that, it starts to gradually release pressure from the arm cuff.

The first pressure reading is the Systolic blood pressure level. As the pressure starts going down, once it drops below the systolic blood pressure level, the blood flow through the artery will return, but the flow will be turbulent as long as the artery remains partially compressed. From the sensor side, once the pressure in the cuff drops below the systolic blood pressure level, we will have a muffled pulsating (heartbeat) signal, as soon as we notice that phenomenon, we take a reading from our sensor for the systolic pressure.

The second pressure reading is the Diastolic blood pressure level. As we continue releasing pressure after reading the systolic blood pressure, we will continue to read the muffled pulsating signal (due to the turbulent flow) until the pressure in the arm cuff drops enough for us to have smooth blood flow. At the point when we get the smooth flow (when the Korotkoff sounds disappear), we take a reading from our sensor, and that is the diastolic blood pressure.

The above, of course, is just a simplified version of everything, but it's enough for me to go on to try and measure blood pressure.

3. Choosing a sensor

My goal is to tap into the hose leading to the arm cuff on a commercial blood pressure monitor in hope of trying to recreate the numbers from the raw data. In this way, I won't have to worry about the pump and the validity of the results, because I can cross-validate them with the ones from the commercial unit. The first thing we need is to define the range of pressure that our sensor needs to measure. The blood pressure measurements are taken in mmHg. Normal blood pressure is 120/80, but in cases of higher blood pressure, it can go up to 200, so a safe bet would be to have a range of at least 250mmHg, which is around 33kPa.

The sensor I went with is the MPS20N0040D-S, it has a pressure range of up to 40kPa (300mHg), works with 5V, and is used in some commercial blood pressure monitors. As mentioned in my first blog, I ordered a few of them, some with additional electronics, and some just bare sensors from AliExpress, in hopes of receiving anything by the deadline, and I got one of them with the additional electronics.

The additional electronics on the small PCB consist of a 24-bit ADC (HX710B) and a few passive components that go along with it. The HX710B similar to the HX711 is an ADC that is most commonly used for things like scale sensors but is a great pick here too since the pressure sensor is just a resistor network. This also means that the sensor is rather easy to use with an Arduino.

Relevant links:

There are a lot of different libraries for the Arduino and the HX710B, while working on this, I managed to find at least 3, and they all gave good results. I linked one of them above.

4. Experimenting with the sensor

Before I get into all of the experimenting, I first need to describe the setup I will be using for this sensor. The arm cuff is connected to the blood pressure monitor with a soft rubber tube. In order to measure the same blood pressure, I either need to make something that goes in between the tube and the blood pressure monitor, or I need a small T joint that I can put somewhere along the tube. Luckily, my dad managed to find me a small T joint, so I went with that approach, which made everything much easier to connect together.

The gray tubing is the tubing from the blood pressure monitor, as you can see in the picture above, it is slightly larger than the black tubing which was designed for this T joint. To make it work, I left a piece of black tubing on the T joint and put the gray tubing over it, and secured it with a small zip tie to make sure it can hold pressure.

The rest of this section will be dedicated to the trial and error method of my trying to get good readings with this sensor so I can get the raw blood pressure data. My general idea is to use the Arduino to just read the data from the sensor in a loop and send them over Serial, where a Python script can run on my computer collecting all of that data and storing it in a CSV file or something similar. But before getting into data logging I used the built-in serial plotter available in the Arduino IDE, it's a great way to easily visualize data in real-time.

Blood pressure measurement - Attempt 1

First of all, I of course just tried to see if I could successfully read the sensor data, which was easy using the HX710B library. After that, all I had to do was connect all of the tubes as shown in the picture below.

After connecting everything, it was time to give this system a try. And this is where I started hitting my first problems. The blood pressure monitor I used has a readout on the screen of the pressure as it's trying to pump up the arm cuff, and when the reading on the blood pressure monitor topped around 100-140mmHg, the sensor readings just topped and didn't measure anything above that. I tried a few times but got the same result every time, which is strange since the advertised sensor range is double what I managed to measure. Before I continue talking about the sensor, let's look at what I actually managed to record with this limited range.

Even though I couldn't use the full range that I need to get the systolic blood pressure, we can still do some analysis on this data. When we look at the graph, we can clearly see that the pressure is having a downward trajectory as the blood pressure monitor is letting air out, but also, we can clearly see the pulses in the readings, which is what I hoped to see all along. Another thing we can notice is how prominent the pulses are in the data. The 2 pictures below show the differences in how we see pulses at the start (first picture) and when we reach the diastolic blood pressure (second picture).

You can see that pulses are much more easily visible compared to the data around in the first picture compared to the second. In the second picture, we can also see a sudden pressure drop at the end, that's the moment when the blood pressure monitor decided the pulses are so faint in the data, that it can read the diastolic blood pressure and let all of the pressure out of the arm cuff. Even though for now, I wasn't able to capture the whole range of data that I wished to capture, this is still a great result in my book. Compared to the MAX30100 and MAX30102 sensors (HR Click and OXI5 Click), I think this method is much more suited for looking at heart rate regularity since it can't be affected that much by how the user is interacting with the sensor.

This is of course where my journey of trying to get the full range of data out of my sensor began. The first thing I did was take the arm cuff off and held it in my hand so I can record the sensor readings topping out while the blood pressure monitor was pumping it up. Here is the video of that.

On the bottom right you can see (and hear) the blood pressure monitor trying to pump the air cuff while I'm holding it in my hand so it can build up pressure. If you stop the video, you can see that already from around 108mmHg to the sensor starter topping out on the serial plotter. Here is a screenshot of that.

And here is a screenshot of the data after the whole test.

As you can clearly see, without changing something, it would be impossible to get the full range of measurements that we need to actually read the blood pressure data from it.

Connecting directly to the sensor - Attempt 1

I tried multiple libraries, but obviously, that won't help, since the reading I was getting was the max reading that the HX710B can provide. Next, I wanted to do was a test if the problem is related to the sensor or the ADC that's on the PCB. To test this out, I had to connect to the sensor directly so I can check if I can get any response for pressures that are above the 108mmHg. To know what kind of pressure is in the system, instead of the arm cuff I put in an analog manometer (from an old manual blood pressure measurement set) and instead of the blood pressure monitor to provide the pressure, I used a syringe.

This way, I can easily control the pressure in the system using the syringe and have a readout of the actual pressure on the analog manometer. In order to get measurements from the sensor, I went the fully analog electronic way and just had a multimeter at the end. Here is a block diagram of the final setup.

Now, of course, comes the fun question, what kind of analog electronics do we need so we can get a reading from the sensor using a multimeter? The first thing I did was take another look at the datasheet for this sensor that I've linked above. Under the pinout of the sensor is this schematic.

On the schematic is a difference amplifier, with all of the resistors of the same value, we just get a voltage difference at the end. By tuning the resistors, we can also get an amplification from this part of the circuit, but I decided to keep those stages separate to keep everything a bit easier to tune. The voltage difference between Vout = V2 - V1 is too small to be useful for us as it is, so, we need a noninverting amplifier added to it. After a bit of playing around, I found that the amplification with which I can see some results is around 170. So here is the full schematic needed to get the measurement I needed.

With everything connected, here is what the final setup looked like.

The analog manometer can go up to 300mmHg which is also the range of our sensor which means we can easily test it through the whole range. The main goal of this test was to see if we can any readings at the top end, above the 100-120mmHg range. So all that was left to do was to put some pressure using the syringe and see if we can see any voltage difference at the end.

As you can see from the video, I have a dead zone now at the lower part of the pressure range, but once I go above around 180-200mmHg, you can see the voltage change with the analog manometer needle moving, and not only that, but if I try keeping it at a certain pressure without moving my finger too much, the voltage doesn't change too much, meaning the sensor is working as it should, and for some reason, I'm either having problems with the ADC or the connection between the sensor and the ADC.

Looking at the HX711

While looking at the HX710 and its specs, I decided to look at the HX711, in hopes of maybe trying to connect the sensor to that ADC with the hope of better results. It turns out, I completely missed one thing that I've seen a lot for the HX711, and that is the gain. The problem was obviously that the sensor just went out of the range of the ADC, hence, why I was getting those cutoff measurements. Reading a bit online, about both the HX710 and HX711, they both communicate in exactly the same way, and there is a function to set the gain for the preamp on the ADC (HX711). Not having seen that in any other library, I tried my luck by using the HX711 library on the HX710 and it worked! Well, for the most part, it worked. The available gains should be 32, 64, and 128 (default), but on the HX710 I could only go as low as 64, which didn't get me the full range that I would need, but still got me a lot closer to what I wanted.

As you can see in the video, I managed to get readings up to 180mmHg, which is a lot higher than I used to get. I just adjusted the values with a single scale factor, and here are the raw values on the serial monitor compared to the values that you can see on the analog manometer.

There is a slight difference, but overall, I'm really happy with how accurate the readings are. I'll take this to be good enough for now, and if I see that It's not, I'll maybe try desoldering the sensor and connecting it to the HX711, since I have a few of them laying around. Here is the code I used for getting the results above.

#include "HX711.h"

const int LOADCELL_DOUT_PIN = 3;
const int LOADCELL_SCK_PIN = 4;

HX711 scale;
float pressure;

void setup() {
  Serial.begin(115200);
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  scale.set_gain(64);
}


void loop() {
  if (scale.is_ready()) {
    //pressure = (scale.read() + 8388607) / 93207.00;
    //pressure = scale.read() + 8388607;
    pressure = scale.read();
    Serial.println(pressure);
    
  }
}

5. Data

Before I continue with the testing, there's one more part that I need to get worked out, data logging. The 2 simplest ways to do this would be to either have a microSD module on the Arduino to log the data directly to the microSD or the way I chose to go about it, to have the Arduino connected to the laptop, and have a Python script running in the background which just grabs new data as Arduino is sending it (Serial) and logs it into a CSV file.

Data logging

To gather the data, all we need in Python is to use the serial library, and for logging the data into a CSV file, we can use the CSV library. Because this is a program I want to run many times as I'm conducting experiments, the first part of the program will be dedicated to checking what's the latest dataset file and creating a new one with a number higher than the previous max one. This can of course is modified to take additional arguments from the user like who's blood pressure we're measuring during the test, the name of the test, and so on.

import csv
import serial
import time
import os

path = 'D:\\Projects\\HMS\\recorded_data'
file_name = 'dataset'
counter = 1
file_path = ''

try:
    arduino = serial.Serial("COM3", 115200)
    print('Established communication to the Arduino, COM3, 115200')
except:
    print('Error establishing a communication with the Arduino')
    print('Exiting')
    exit()

# Creating a new data file path + data + first_free_number
while True:
    file_path = path + '\\' + file_name + str(counter) + '.csv'
    if os.path.exists(file_path) == False:
        print('Creating new dataset file: ' + file_path)
        f = open(file_path, 'w')
        f.close()
        break
    else:
        counter += 1

print('Starting to record the data')

while True:
    with open(file_path, 'a', newline = '') as csv_file:
        csv_writer = csv.writer(csv_file)
        data_point = float(arduino.readline())
        csv_writer.writerow([str(data_point)])

The important thing is to check on what COM port our Arduino is (easily done through the device manager or Arduino IDE) and to make sure we're using the same baud rate.

Data plotting

The other thing we need to do is to present the data somehow, and the easiest way to do that is in a plot. For that, I wrote another small Python script that takes the file that we've just recorded and plots the data out. It's easy to modify cosmetic parameters inside the code and the code also saves a high-quality image of the plot in the same folder as our Python script.

import csv
import matplotlib.pyplot as plt
import scipy as sc

data_file = 'dataset13.csv'
measurements = []

with open(data_file, 'r') as csv_file:
  reader = csv.reader(csv_file)
  flag = True
  for row in reader:
    if flag == False:
      flag = True
    else:
      measurements.append(float(row[0]))



# plot
fig, ax = plt.subplots()
ax.grid(axis = 'both', color = 'black', linestyle = '-', linewidth = 0.2)
ax.set_title('Blood pressure measurement - Measuring Range')
ax.set_xlabel('Reading number')
ax.set_ylabel('Pressure [mmHg]')
ax.plot(measurements, linewidth = 0.8, color = 'b')
#ax.legend()
#ax.set(xlim = (10, 30), ylim = (30, 70))
fig.savefig('BloodPressureMeasurement6.png', dpi = 300)
plt.show()

Since we need access to the hardware ports on our computer for the first script, we need to run it on a local instance on something like Spyder or Visual Studio Code, while the second script can be run in online compilers as well. I generally try using online compilers like Google Colaboratory since they provide flexibility from where I can edit the code, and library installation is a breeze if there is a need for that at all. Here is a plot showing the pressure I recorded while playing with the Syringe setup that I've shown above.

6. Measuring blood pressure

After all of those tests and setbacks, it's time to finally try and record an actual blood pressure measurement, to see if we can see anything from the data. I'll upload all of the CSV files I talk about here if you wish to give it a try yourself to see what you can do with the data.

Measurement 1 - 120/79/79

This is the first measurement I took, I did the measurement on myself, and my blood pressure was 120/79 with a pulse of 79. That was extremely close to the 120/80, missed it by 1! During the measurement, I recorded 2338 points of data, but that also includes the part until I pressed the start button on the blood pressure monitor, until it pumped up the arm cuff. If you wish to try working with the data yourself, you can download it here (It doesn't allow me to attach CSV files, so I've uploaded it as a code that you can copy and paste into notepad and save as a CSV).

Here is what the plotted data looks like.

I managed to get a whole recording, but you can see the cutoff in the middle again. Also, you can notice a pretty large offset at the beginning and the end, which is something I haven't seen at all while working with the analog manometer. So there is still work to be done on the sensor side. Nevertheless, we can still take a look at the data that I've recorded a bit closer, or more specifically at the region where the blood pressure monitor is letting the air out so it can do its measurements.

One thing we can check is the heartbeat since it's clearly visible from the graph. There are 2 potential things that we can look at, and those are the BPM (Beats Per Minute) and the regularity of the heartbeat. To get the first one, we need actual timing to check that, which we can easily do by modifying the setup so that the Arduino also provides "millis() " with the sensor reading. As for the heartbeat regularity, this is something that we can check even from here just by how far the heartbeat detections are from one another. The first thing we need to do is locate all of the peaks in oscillations. We can do that using the scipy library in Python.

import csv
import matplotlib.pyplot as plt
import scipy as sc
import numpy as np

data_file = 'dataset11.csv'
measurements = []

with open(data_file, 'r') as csv_file:
  reader = csv.reader(csv_file)
  flag = True
  for row in reader:
    if flag == False:
      flag = True
    else:
      measurements.append(float(row[0]))

measurements = measurements[1450 : 2075] #11

x_positions = sc.signal.find_peaks(measurements)[0]
y_positions = [measurements[x] for x in x_positions]


# plot
fig, ax = plt.subplots()
ax.grid(axis = 'both', color = 'black', linestyle = '-', linewidth = 0.2)
ax.set_title('Blood pressure measurement - Heartbeat detection')
ax.set_xlabel('Reading number')
ax.set_ylabel('Pressure [mmHg]')
ax.plot(measurements, linewidth = 0.8, color = 'b')
ax.scatter(x_positions, y_positions, color = 'r', linewidths = 0.1)
fig.savefig('BloodPressureMeasurement9.png', dpi = 300)
plt.show()

This will look for all local maximums in our dataset. The function that is responsible for that is this one.

x_positions = sc.signal.find_peaks(measurements)[0]
y_positions = [measurements[x] for x in x_positions]

This way we get the indexes and from there we can get the values from our data using those indexes. All that's left to do now is to scatter plot these dots onto our data.

Due to the cut-off at 180mmHg and the nature of the measurement, to check the regularity, I won't use the first and last detected heartbeat, but we can use the rest to see how the delta changes between them through the measurement. We're only interested in the time axis, which is the x-axis.

From the plot above, we can see that the heartbeats are around 31-36 readings apart. The thing we're interested in is how wide the range is because that will give us a clue about the irregularity. We can do this by subtracting the mean value from the delta values that we calculated for the plot above.

From this last graf, we can see that the deltas aren't that different as the measurements grow. We can go a step further and try to convert these graphs into time using the average BPM I got from the blood pressure monitor which was 79. Using that, we can calculate the average time between 2 heartbeats and then use that on our data.

avg_bpm = 79
time_between_heartbeats = 60 / avg_bpm
time_intervals = len(heartbeats) - 1
num_measurements = heartbeats[-1] - heartbeats[0]
avg_time_between_measurements = (time_intervals * time_between_heartbeats) / num_measurements
print(avg_time_between_measurements)

We get that the average time between two measurements using the measured heartbeat is 0.023202454 seconds. Again, it would be easier if we used the "millis()" function directly in Arduino, but this is something that we can do with this data. All that's left to do now is to integrate that data into the last 2 plots.

The delta values here are in seconds, which shows how far off the beats are from one another. My goal with these graphs was to look for an irregular heart rate, which would show up on graphs as an extremely short delta followed by a long delta, but something I've learned about while researching this topic is HRV (Heart Rate Variability). If the heartbeats are "too" regular, it usually means that the person is in fight or flight but if there are some smaller differences between the deltas, it means that the person is more relaxed and can be a sign of better cardiovascular health. From the second graph, you can see that my HRV can go upwards of 80ms which is considered healthy. I am no expert on this topic, but I found it interesting as another piece of data that I can pull out from my measurements. Below is the code used for generating the delta plots.

heartbeats = x_positions[1 : -1]
print(heartbeats)
deltas = []
mean_val = 0

for i in range(0, len(heartbeats) - 1):
  deltas.append(heartbeats[i + 1] - heartbeats[i])
  mean_val += heartbeats[i + 1] - heartbeats[i]

mean_val = mean_val / len(deltas)

fig, ax = plt.subplots()
ax.grid(axis = 'both', color = 'black', linestyle = '-', linewidth = 0.2)
ax.set_title('Heartbeat delta')
ax.set_xlabel('Reading number')
ax.set_ylabel('Delta')
ax.plot(deltas, linewidth = 0.8, color = 'b')
fig.savefig('BloodPressureMeasurement1-Delta.png', dpi = 300)
plt.show()

fig, ax = plt.subplots()
ax.grid(axis = 'both', color = 'black', linestyle = '-', linewidth = 0.2)
ax.set_title('Heartbeat delta')
ax.set_xlabel('Reading number')
ax.set_ylabel('Delta')
ax.plot([delta - mean_val for delta in deltas], linewidth = 0.8, color = 'b')
fig.savefig('BloodPressureMeasurement1-DeltaCentered.png', dpi = 300)
plt.show()

avg_bpm = 79
time_between_heartbeats = 60 / avg_bpm
time_intervals = len(heartbeats) - 1
num_measurements = heartbeats[-1] - heartbeats[0]
avg_time_between_measurements = (time_intervals * time_between_heartbeats) / num_measurements
print(avg_time_between_measurements)

fig, ax = plt.subplots()
ax.grid(axis = 'both', color = 'black', linestyle = '-', linewidth = 0.2)
ax.set_title('Heartbeat delta')
ax.set_xlabel('Reading number')
ax.set_ylabel('Delta')
ax.plot([delta * avg_time_between_measurements for delta in deltas], linewidth = 0.8, color = 'b')
fig.savefig('BloodPressureMeasurement1-DeltaTime.png', dpi = 300)
plt.show()

fig, ax = plt.subplots()
ax.grid(axis = 'both', color = 'black', linestyle = '-', linewidth = 0.2)
ax.set_title('Heartbeat delta')
ax.set_xlabel('Reading number')
ax.set_ylabel('Delta')
ax.plot([avg_time_between_measurements * (delta - mean_val) for delta in deltas], linewidth = 0.8, color = 'b')
fig.savefig('BloodPressureMeasurement1-DeltaCenteredTime.png', dpi = 300)
plt.show()

Measurement 2 - 105/68/68

For the second measurement, I asked my mom to volunteer, because she usually has lower blood pressure, and I wanted to see if I can get a better reading due to my sensor problems. Before I get into the plots that I've generated for that dataset, you can find the measurements below. Copy them into the notepad and save the file as a CSV. The code used to process and work with the data is the same as above. One thing I changed here is instead of using the converted values, I used raw readings from the ADC since I didn't have too much confidence in the accuracy of the numbers after the first measurement,

Here is the first graph showing the data from the whole measurement.

As for the first measurement, we can now first focus on the part where the arm cuff is slowly deflating and where we can see the pulse.

Now, we can find the heartbeats by finding the peaks of all of the oscillations that we can see in the plot.

And in the end, we can take a look at the 2 delta graphs. I just changed the BPM from 79 to 68 for the calculation, since that was the measurement that my mom got on the blood pressure monitor.

As you can see by comparing the results from me and my mom, you can see I have a slightly higher HRV than her, which is normal considering that I'm younger and that she was walking around and working before taking her measurement. But the graphs also show that no irregularities were noticed.

One thing that I have to point out of course is that this was just my curiosity about what I can pull from this data and that for actual medical measurements, there are way better ways of tracking HRV, though, for something like more serious heart rate irregularities, I feel that this method would be sufficient in finding them.

7. Summary

This is where I'll leave this part of the project for now. As I said at the beginning of this blog, I was writing this blog as I went and didn't know how successful it would be. Looking at it now, I didn't achieve my end goal of actually producing the numbers, but it went way better than I expected it to go when I look back at how it started. I didn't manage to get the blood pressure reading, but I did manage to actually record the pulse using the pressure sensor, rather reliably. I left the raw data in the blog if anyone wants to try working with it. I have some other aspects of the project I need to concentrate on now but will come back to this portion as well. The goal with this part will still be to get a blood pressure reading, but looking at the results now, I can say for sure I can at least add a heartbeat buzzer to a commercial blood pressure monitor that doesn't have that feature. It maybe sounds like a gimmick, but this is something that we found incredibly useful when grandma needs to take here blood pressure measurements. Thanks for reading the blog, hope you found it interesting and enjoyed it!

Milos

Top Comments

milosrasic98 over 2 years ago in reply to saadtiwana_int

Hi, thanks for reading! I mostly use GoodNotes5, since it's fast and easy to get geometric shapes, but also allows for simple free-hand sketching without anything fancy (brushes, layers, etc). My whole idea with the sketches was to "digitalize" ordinary pencil and paper sketches, so that's the look I was going for.
- Cancel
- Vote Up 0 Vote Down
- Sign in to reply
- More
- Cancel
saadtiwana_int over 2 years ago

Interesting blog post, thanks for sharing. Btw, I am curious what software/tools you used to draw those nice illustrations, for example under the heading "6. Measuring blood pressure"?

- Saad
- Cancel
- Vote Up 0 Vote Down
- Sign in to reply
- More
- Cancel