IR Heartbeat Display

Introduction

In this lab, we will use our developed knowledge of I2C, Serial, and Bluetooth communication to develop a system that can detect our heartbeat through the use of an IR emitter and IR receiver. Once this circuit is established, we will move on to filter the output signals (our heart beat) with both analog and digital filters. Filters are introduced in this lab as they are a powerful tool in the world of signal processing as they allow you to literally filter out the signal you want while getting rid of unwanted "noise".

Then we will use this heart beat sensor to test different locations on our body that are optimal for producing the best signal. Different parts of the body have different effects on how the IR sensors detect heartbeat due to difference in skin thickness, blood flow, dense muscles, etc. Spoiler alert: turns out the wrist is actually not the ideal location for heart rate detection! (I wonder why so many wearables are strapped to the wrist?)

Finally, we finish the lab by creating a heartbeat display using the OLED used from the previous lab. However, we will also implement a Python script that can read data from the Arduino via Bluetooth and store/plot the data we receive. This will be accomplished through the use of two strong Python libraries commonly used in the industry: Numpy and MatPlotLib. Through the successful completion of this lab, you will not only further enhance your skills in Arduino/Python development, but have a functional heart rate sensor in your possession!

Objectives

1. IR Heartbeat Circuit
2. Analog Filtering
3. Digital Filtering
4. IR Placement
5. Heartbeat Display

Objective 1: IR Heartbeat Circuit

Part A: Create a basic IR emitter and receiver circuit with the Arduino so that it can read heartbeat.

1.) First, we begin by setting up the circuit on the breadboard with the IR emitter and IR receiver. The circuit is setup using the diagram on Figure 1 & Figure 2 below:

Note the polarity on the IR emitter and receivers. The longer leg will be the positive end and the shorter leg will be the negative terminal. The same goes for the capacitor (1 uF). The result should look something like this:

2.) Next, we will sample analog signals from the Arduino's A1 pin, and use Arduino's built-in Serial Plotter function to display the results. The code is given below:

Once you copy and paste the code into your Arduino sketch, upload it to the board and run it. Once the code begins to run, open Serial Plotter (Arduino >> Tools >> Serial Plotter). Place your finger on top of the IR emitter and receiver to check your heartbeat. The results should resemble something like the picture below:

3.) Congratulations! You have just created an IR receiver/emitter circuit that can check your heartbeat. There are a few things to note about this objective:

• The circuit checks the change in blood volume in your finger by emitting and IR signal, and receiving that same signal with the IR receiver. The emission/receipt of the IR signal through your fingers shows the change in blood volume, thus enabling us to check for a heartbeat.
• Notice that the signal, while it has visible heart "beats", tends to appear choppy and rather rough. This is due to the Arduino's built-in ADC (Analog-Digital Converter). Essentially, the Arduino converts the analog signal that it receives from the IR receiver to a digital form of itself in order to display it using the Serial plotter. However, this conversion usually causes the data to lose its accuracy as the ADC is limited to its voltage reference and other things. This loss of accuracy then translate to a much rougher and choppier looking signal (shown in the plot above). In the next objective, we will try to correct this signal using an operational amplifier (Op-Amp).

Part B: Amplify the heartbeat signal using an Op-Amp.

1.) Now that we have a working heartbeat sensor, we must get a more consistent and smooth signal. This can be done using an Op-amp to amplify the analog circuit we receive from the IR receiver. Set up the Op-amp circuit according to Figure 3 and Figure 4 below:

2.) Note that not all the pins on the Op-amp need to be connected. Pins 1, 7, and 8 are not connected to anything. Your circuit should resemble something like this:

3.) Using the same code as Objective 1A, run the Arduino code and put your finger on top of the IR emitter and receiver to obtain a heart rate in Serial Plotter. You should notice a significantly smoother signal that resembles something like the one shown below:

4.) Congratulations! You have successfully amplified your heartbeat signal using the Op-amp to provide a much more consistent signal to the Serial Plotter. To explain how this feat was accomplished, it is important to note exactly what the Op-amp does.

• The Op-amp takes the signal from the IR receiver and amplifies it before sending the signal to the Arduino's A1 analog pin
• This will therefore provide a larger signal for the Arduino to work with when converting the signal from an analog one to a digital one via the ADC. Due to the nature of the amplified signal, the outcome is a signal that has a more accurate resemblance of the one received from the IR receiver!
• Note that this concept is not only limited to IR signals. An op-amp can be used just as easily to amplify other types of signals (e.g. audio signals). Due to their amplifying property, op-amps are commonly used in electronics to provide better signals for devices to convert!

Objective 2: Analog Filtering

Add an analog Low-Pass Filter (LPF) to your circuit to reduce noise from the IR signal.

1.) First, set up the LPF on your circuit using resistors and capacitors. You should always disconnect the Arduino prior to touching the circuit elements to prevent the chance of short-circuiting your entire setup. Reference Figure 5 and Figure 6 to assemble your new circuit:

The circuit you construct should resemble something like this:

2.) As before, upload the same Arduino code to your circuit and run it. Put your finger on top of the IR emitter and receiver, and on the Serial Plotter screen, you should notice a significant reduction in noise (signal jitter). The result should look similar to the following plot:

Note that the heartbeat signal here has less jagged curves compared to the signal from the circuit without the LPF. In other words, adding the analog LPF to our circuit helped "smoothen" out our IR signal curves. The signal also appears to be more amplified. This is simply a result of the reduction of noise, which correspondingly adjusts our graph scale to better represent the amplitude of our wanted IR signal.

Objective 3: Digital Filtering

Part A: Add a digital filter on top of the current circuit by adding an extra output wire to analog pin A0 on the Arduino. Apply a digital LPF with a 2.0 Hz cutoff frequency to the amplified signal in A0.

1.) Now we introduce the idea of digital filtering in this objective. To start off, we must add an extra output wire for the Op-amp to send a signal to the Arduino's A0 analog pin. This can be done by simply adding an extra wire as shown in Figure 7 and Figure 8.

The final circuit should resemble something like the one shown below (note that there are two wires, one going to pin A0 and another going to pin A1):

2.) Now that we have an extra signal from the Op-amp, we must update the Arduino code to display this extra signal as well. We will separate the values from the two signals (A0 and A1) by adding a tab character (\t) in between them when writing to Serial. The resulting code is below:

The code will therefore print to the Serial plotter the sensor value from A1 followed by the sensor value from A0, which are separated by a tab character (\t).

3.) Upload and run the code to your Arduino. Open the Serial Plotter and place your finger on the IR receiver and emitter to check the heart rate again. You should notice two signals on the Serial Plotter (one blue and one red). The red signal is from the analog pin A0 and the blue signal is from pin A1. The result from checking your heart rate should resemble something like this:

You can notice a significant difference between the A0 and A1 signals from the resulting graph. The red A0 signal output has more noise shown by the rough curves, whereas the blue A1 signal output has less noise shown by the smoother, more consistent curves. This is because the red A0 signal has only been amplified by the Op-amp, but no filters have been applied to it. The blue A1 signal has been both amplified by the Op-amp and filtered with the analog LPF on the circuit board.

Now we can manipulate the red A0 signal by adding a digital filter over it. This filter will be a digital LPF with a cutoff frequency of 2.0 Hz. The resulting curve should have less noise than the one depicted in the previous graph.

4.) In order to implement a digital filter, we must first install the digital filter library for the Arduino. The library can be found in The GitHub repository. Simply download the folder, unzip the folder, and add it to the Arduino "libraries" directory on your computer. Once this is accomplished, restart the Arduino IDE and verify that the library has been installed (Arduino >> Examples >> Examples from Custom Libraries).

Upload the following code to your Arduino and run it to verify that it works:

There are a few updates to the code from the previous one in order to get it to work properly. These updates include:

• The first line, where we include the Filters.h library
• Establishing a float type variable filterFrequency as our cutoff frequency variable.
• Declaring an object of class FilterOnePole and naming it lowpassFilter.
• Rather than reading directing from analogRead() to sensorValue2, we call the "input" function of the object lowpassFilter.input( analogRead(A0) ) to pass the values from the digital LPF to sensorValue2, which is then printed to Serial.

3.) Run the Arduino code and check for your heart rate once more. You will obtain a graph similar to the one shown below:

4.) Congratulations! You have successfully applied a digital LPF with a cutoff frequency of 2.0 Hz to your red A0 analog signal. You should notice that unlike the previous graph obtained, this graph reveals a red A0 signal that is considerably smoother than the blue A1 signal. This is due to the fact that the digitally filtered A0 signal does a better job at filtering noise due to its digital nature. The blue A1 signal has an analog LPF, which means that the actual resistors and capacitors are responsible for filtering the signal, and due to their physical nature, the resistors and capacitors are subject to signal loss (e.g. faulty wires, noise from the breadboard, etc.).

From this result, we can conclude that the digital filter does a better job at filtering the noise from the IR signals compared to the analog filter. The digital filter is also easier implement as it does not require any physical circuit components like the analog filter!

Part B: Apply a derivative to the digitally filtered signal. Then apply two more transformations of your choosing and justify why you chose those transformations.

1.) The digital LPF successfully improved the quality of our signal, but to fix the issue of inconsistent amplitudes, we can apply a derivative to the signal as well. To implement a basic derivative, we can just take the difference between the current analog output and the previous analog output. This is done in the following code:

Upload the code into your Arduino and run it. You should get an output in the Serial Plotter similar to the following graph:

2.) Next, we will apply an inverse to the output signal. This can be done by simply inverting the output of the digital LPF signal in the code:

An inverse filter simply shows the inverse of the original output. This can be useful when you need to visualize a signal's change as a decremental transformation, rather than an incremental one. In other words, this will allow us to see the heart beat as a dip, rather than a spike. The output signal on Serial Plotter should look like the following:

3.) Another transformation of the signal we can do is the bandpass filter. The bandpass filter is simply a combination of the lowpass and high-pass filters. Here we will implement a bandpass filter at the 2.0 Hz frequency (LPF) and 1.0 Hz (HPF):

Note that the HPF and the LPF are applied at different frequencies. This is so that the LPF will filter signals above 2.0 Hz and the HPF will filter signals below 1.0 Hz. By doing so, we can visualize the effects of what a band-pass filter will have on our output signal. Bandpass filters are extremely useful for filtering signals within a specific frequency range (in our case, 1.0~2.0 Hz). The output should resemble the following graph:

Objective 4: IR Placement

Explore alternative locations to measure heart beat for our IR circuit.

1.) In this objective, we will explore alternative locations on the body that can be used to measure heart rate. So far, we have been using our finger to measure the blood pulse, but there could be regions of the body that will allow easier/more accurate readings. Therefore, we need to first modify our circuit to be more flexible for movement. This can be done by following the diagram in Figure 9. An actual picture of the circuit assembled is also shown to the right below:

2.) With our circuit assembled, we can now check for heart beats in different regions of the body. First, we will measure the heart rate from the fingertip as before. Reusing the code from Objective 1, we obtain the following output:

3.) Next we obtain the heart rate data from our wrist. Follow the same procedure of obtaining heart rate except we will place the IR emitter/receiver on our wrist. The following output was plotted on Serial Plotter:

4.) Lastly, we will repeat the same procedure but for our neck right next to the atom's apple. The following output plot was obtained from measuring heart rate via the neck:

5.) Congratulations, you have successfully completed this objective. Before we move on to the next objective, you should notice that there were some significant advantages/disadvantages of each different region that we measured heart rate from.

The fingertip was easy to measure a consistent heart beat from when compared to the other locations, but a disadvantage was that it can often be difficult to keep your fingertip extremely still. Movement in the finger can easily disrupt the signal output.

The wrist outputted inconsistent signals for the heart rate. However, it was much easier to keep your wrist still than the finger.

The neck was chosen as a location as most people check the neck for a pulse when measuring their heart rate. The neck seemed to output a signal quality worse than that of the fingertip, but better than the wrist. The neck is also quite an easy region to keep still during the heart rate measuring period.

Objective 5: Heartbeat Display

Part A: Map the IR amplified signal, from Objective 4, to the OLED.

1.) First, we need to assemble our circuit so that the OLED display is added. Refer back to Lab 1 for the diagram on how to wire the OLED display. The circuit should look similar to the one below:

2.) Next, we want to write an Arduino code that will translate the IR signal data to something that can be displayed on the OLED display. For this objective, we will display the heart beat as the Serial Plotter displayed it, but on the OLED. There are some things to keep in mind:

• The OLED display has a limited amount of pixels (the x-range is from 0 to 127, and the y-range is from 0 to 31). So we need some sort of a scaling factor to multiply the IR signal by. This scaling factor is simply,

Scaling Factor = Maximum Height of OLED / Maximum Range of IR Signal

Scaling Factor = 32 / 100

• We can display the pulse by drawing a pixel on the y-axis corresponding to the value we get from the IR signal. The x-value of this pixel will simply be from 0 to 127 that is incremented after each iteration of the Arduino's loop, and reset back to 0 once it reaches the value of 127.
• Keep in mind that the OLED's x-y coordinate system has the origin at the top left corner of the display, and the positive x-axis is towards the right and the positive y-axis is towards the bottom. This means that we need to orient the signal value so that the spike in the heart beat is oriented to go toward the top of the OLED display.

This is done simply by taking the scaled y-value of the IR signal and subtracting it from the maximum OLED height:

y-value = (Maximum OLED height) - (scaled y-value of IR signal)

y-value = 32 - (scaled y-value of IR signal)

With these points in mind, we develop the Arduino code below:

Make sure to read through the comments in the code so you understand what the functions and variables are doing!

Run the Arduino code on your board, and watch the OLED display your heart beat. The result should looking something like the picture below:

Part B: Modify the code and circuit from Part A to send raw data over the BLE HM-10 modules. In Python, write a script that measures 20 seconds of raw data, stores it in a file, and plots it.

1.) First we need to establish a circuit so that the HM-10 BLE module will be properly set up. Similar to the previous lab, Lab 1, we will implement a button to make sure the BLE module can go to sleep and wake up based on the button press. Below is a picture of the circuit:

2.) Now we need to modify the code from Objective 5A to work with our new circuit. The code is implemented below:

This Arduino sketch simply combines various features of our previous labs and objectives, such as the button press and sleep/wake function, so make sure to read through it and understand the code! Upload the sketch and run it on the Arduino to make sure the functions work as intended.

You can also disconnect the Arduino from the USB port to your computer and connect it to a 9V battery like in Lab 1. The sleep function allows the Arduino to save battery while running on 9V battery power!

3.) Now we want to write a Python script to read data via Bluetooth from the Arduino for 20 seconds, store it in a file, and plot the data points. The code is displayed below:

The code has been commented throughout for your ease of learning what the code actually does. Make sure to change the set_connect variable to your Arduino BLE module's MAC address, and the name of the output file to whatever you desire. By default, the file name is "lab2_raw_data_jyjang.npy". Run the Python script from Terminal and test the system together with the Arduino!

4.) Congratulations! You have successfully completed Objective 5B. The plot that you see from running the code should map out your heart beat, and it should look similar to the plot below: