Published May 28, 2016 © GPL3+

Building a Electrocardiogram with Windows IOT and Azure

Building a Electrocardiogram using Raspberry Pi and Windows IOT and sending data to Azure IOT Suit.

IntermediateFull instructions provided2 hours12,378

Building a Electrocardiogram with Windows IOT and Azure

Things used in this project

Hardware components

Raspberry Pi 3 Model B

Adafruit ADS1115

SparkFun Single Lead Heart Rate Monitor - AD8232

Software apps and online services

Microsoft Visual Studio 2015

Microsoft Windows 10 IoT Core

Microsoft Azure

Story

This project is not a medical device and is not intended to diagnose or treat any conditions.

Lately I have been studying how to measure human body activity and how to use this data in several ways, for example with Machine Learning.

Lets think about, how nice would be if we may have the possibility to monitor our Heart activity and get useful feedback like possibility of heart attack or a serious arrhythmia.

To show the potential for a project like this, lets build a EKG/ECG device using Windows IOT with a Raspberry Pi 3 and send this Data to the Cloud, using Microsoft Azure (IOT Suit).

First lets us understand what is EKG/ECG and how its work.

EKG is a device that measure the heart's electrical activity during a period of time, using electrodes placed on the skin. This activity may be measured in several parts of the body. The first recorded EKG was reported on 1972 by Alexander Muirhead.

Typical EKG Waveform

To fully understand an EKG/ECG is necessary to understand how the electrical conduction system of the heart works. I will not explore deep how to read and understand this data, but what we need to understand is that the Heart conduction works on a predictable pattern, and that all the information comes from the wavelengths and from the spikes intervals.

To make our understanding easier, lets divide the wave in 2 basics intervals PR and QT, as showed at the picture bellow.

Intervals (picture from WIKIPEDIA - https://en.wikipedia.org/wiki/Electrocardiography)

PR - Is the first wave generated, normally last 120 to 200msQT - Normally last 400ms a prolonged QT interval is a risk factor for ventricular tachyarrhythmia.

To detect this waves the fundamental component is a Instrumental amplifier, which is responsible for measure the voltage difference between the electrodes by amplifying the signal.

If you want to create your own system you can my recommendation is to use components like INA 128 / 129 and filter the noise using Operational Amplifiers like TL702.

A good news is that Analog Device have create a chip that cover all necessary aspects, called AD8232, it is a Single-Lead ECG Frontend, and this make our life really easier.

As the component is really small and require some tools and expertise to assemble we can buy a board ready to use, reducing the need of soldering and facilitating the project creation.

AD8232 Sold by Sparkfun

Of course you can create your own using the Operational Amplifier and will work as good as this one, follow a example :

ECG / EKG Diagram

As a mention before we can place the electrode in several parts of the body, here is some suggestions:

As we know Raspberry Pi doesn't have a Analog to Digital converter so we need a external one, my favorite is the ADS1115. It is a 16-Bit 4 Channel Analog to Digital Converter that has far more accuracy the one used on a traditional Arduino, and also counts with a programmable gain (similar an operational amplifier).

Here is the schematics on how to wire it up.

Raspberry Pi wired up on ADS and Heart Monitor

Now that the electronic part is done and you know where to place your electrodes, let check it out the software from the device and the cloud configuration.

Lets start with the Cloud Setup, so lets log on Azure and create a IOT HUB

IOT HUB inside of Internet of Things

Than lets setup

Initial Setup

And now we need to grab the connection String

Take a note of the Connection String, and that is it for the Event Hub.

The coding part is listed at the session bellow.

Where to go from here, you may explore Azure Streaming Analitics or Machine Learning to analyse this data. But the I think you will really enjoy is to use Microsoft Power BI to plot this graph and see your heart waves

Regards

Chris

Code

Visual Studio Coding - Im using VS 2015 private async void InGpioPinOnValueChanged(GpioPin sender,

using Windows.Devices.Gpio;
using Windows.Devices.I2c;
using System.Diagnostics;
using System.Threading.Tasks;
using Windows.UI.Core;
using Windows.Devices.Enumeration;
using Microsoft.Azure.Devices;
using System.Text;
using Microsoft.Azure.Devices.Client;
....
// Inside MainPage Class
private GpioPin _inGpioPin;

private I2cDevice _converter;

 protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            await InitializeAsync();
        }


  private async void InGpioPinOnValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
        {
            var bytearray = new byte[2];
            _converter.WriteRead(new byte[] { 0x0 }, bytearray);
            if (BitConverter.IsLittleEndian)
                Array.Reverse(bytearray);
            var value = BitConverter.ToInt16(bytearray, 0);
            // Sending Data to Azure
                        DeviceClient deviceClient = DeviceClient.CreateFromConnectionString("your connection key", TransportType.Http1);
            var msg = new Message(Encoding.UTF8.GetBytes(text));

            await deviceClient.SendEventAsync(value);
            
            
        }

        private async Task InitializeAsync()
        {
            var i2CSettings = new I2cConnectionSettings(0x48)
            {
                BusSpeed = I2cBusSpeed.FastMode,
                SharingMode = I2cSharingMode.Shared
            };
            var i2C1 = I2cDevice.GetDeviceSelector("I2C1");
            var devices = await DeviceInformation.FindAllAsync(i2C1);
            _converter = await I2cDevice.FromIdAsync(devices[0].Id, i2CSettings);
            _converter.Write(new byte[] { 0x01, 0xc4, 0xe0 });
            _converter.Write(new byte[] { 0x02, 0x00, 0x00 });
            _converter.Write(new byte[] { 0x03, 0xff, 0xff });
            var gpio = GpioController.GetDefault();
            _inGpioPin = gpio.OpenPin(27);
            _inGpioPin.ValueChanged += InGpioPinOnValueChanged;
        }
  
  
  
  How to Read Data from ADS1115 inspired on the code from  : Oliver Matias MVP http://www.guruumeditation.net/en/analog-io-on-windows-10-iot-raspberry-pi-2-and-ads1115-converter/