Soon, I’ll post part II. I hope to have the heart beats detected so that I can calculate the heart rate. Also, I will be taking measurements from both LEDs and comparing them. By doing this, I hope I can extract the oxygen saturation (amount of oxygen in my blood).

Update: Since filming the video above, I implemented the heartbeat detection and heart rate calculation. In the image below, the heart rate is calculated and show in the upper right. Also, the heart beats are automatically detected and annotated with little hearts.

Screenshot showing automatic heartbeat detection and calculated heartrate (upper right corner)

Already the library supports:
serial – printf(), getchar(), etc
standard I/O – easily make pins input or output, set pins high and low
pwm – LED brightness, motor control
pwm servo – control RC servos
adc – read analog values

Here is a preview reading analog in with the ADC and controling the brightness of an LED using PWM:

I’m still working on making the wiki page match this blog and storing the code in SVN. For an early preview, check out http://tinkerish.com/wiki/.

Background Reading
Wikipedia page on pulse oximetery
principles of how pulse oximetery works
a light intensity to digital frequency part I chose to work with.

Parts Ordered So Far
(1) a TSL230R IC – chip to convert light intensity to something our AVR can read (in this case a digital frequency to measure with our timer counter)
(2) an IR (infra-red) LED – 940nm wavelength
(3) a red LED – 660nm wavelength
* note: all of the links above are to Sparkfun.com and should work great for this project. The LEDs that I ordered will be slightly different because I purchased them from a different source (only because they were out of stock at the time).

Quick Theory of Operation
As your heart circulates blood, your arteries constrict and expand. Also, your lungs add oxygen to the blood making it more red in color. By using a light intensity sensor and some LEDs we can get our pulse rate from the constricting and expanding and we can get the oxygen saturation from the amount of red in the blood.

Ever put a flash light against your cheek to see the light shine through the other side? Just like that, we are going to place LEDs on one side of the finger and measure light on the other side. As the heart beats we should see our output fluctuate with our heartbeat. The IR from our IR led should be pretty uniform in how much it gets absorbed through the finger. I am expecting to see the heartbeat from this with an AC component that changes as the capillaries constrict and expand. The light from our red LED should get absorbed more when the blood is oxygen rich. I am expecting to be able to contrast this with our waveform from the IR led to be able to figure out the oxygen saturation.

Electronics

The output from our TSL230R is a digital output in the form of a frequency. Our AVR will look at this on one of its interrupt pins. We can then use a 16bit timer counter to measure the pulses. These measurements will be equal to the light intensity that the TSL230R sees. The AVR will also control the red and IR leds. This will allow us to turn then on one at a time as we make our measurements.

The first step will be to output to serial (/dev/ttyUSB0). I can then graph the output to make since of it and debug. After that, I will attempt to pull as much of the processing as possible into the AVR. The goal will be to log the pulse rate and oxygen concentration to the SD card. An LCD may also be added. Last, I may add a peizo buzzer so that it can alert you when the measurements are not accurate or if there is a problem.

Anyone wishing to follow along at home should get some parts on order

I have a Canon DSLR camera. I wanted to take a timelapse video of my Aerogarden.The only way to do timelapse is to either connect a PC running Windows or to use the remote shutter port. It is basically a 2.5mm audio jack. If you short one of the 2 conductors to ground it focuses. If you short the other to ground it takes a picture. I rigged up an AVR and some relays to take a picture about every 30 minutes. A script was written to look at the EXIF data in the pictures to overlay the days that have passed.

Many people have heard of Arduino. It is an AVR based platform with standardized I/O and form factor. It goes with a software stack on top that makes programing easy. Too easy, IMHO. The list that I provide below will include an Arduino base board. This is because it can be used for generic AVR programing as well without using the extra software stack. Because of its popularity, the economies of scale make it an inexpensive starting place.

Arduino Pro 3.3v/8mhz base board – $19.95
USB Programmer - $14.95
USB to TTL serial board 3.3v – $13.95
breakaway headers – $2.50 (get a few of these)
colorful jumper wires – $3.95
breadboard – hopefully you already have one of these … the arduino pro will plug right into one

Total – about $55

The parts I’ve chosen are for 3.3v. This is because most of the things that I interface with are 3.3v and I like to run my stuff off of 3.6-7v lipos directly. 5v versions are available also.

The objective of this project is to log one’s heart rate to an SD card. This could be done for extended periods, including during sleep, for some pretty interesting investigation. What is shown in the video is the logging of a treadmill session with periods of jogging and walking to see the fluctuations in heart rate.

Details

As a baseboard, we continue to use our custom Atmega8 / Atmega168 through hole board. Attached to this, we have a custom SD breakout since it is a little cleaner than soldering to the SD card adapter sleeve. For power, we simply use a 3 AA battery holder (provides 3.3-3.8v). Most importantly, we use the Poler OEM module from Sparkfun.com to receive the heart rate. Typically, Polar sells chest strap and watch combos. The chest strap goes on your chest (duh) and the signal is picked up by and displayed on the watch. We simply use the OEM receiver module to also listen to the signal.

The Polar OEM heartrate module outputs a pulse each time it detects a heart beat. We tie this signal to an interrupt pin on our AVR. We use the duration between pulses to calculate the heart rate. The F_CPU (frequency of the CPU) is used in the calculation of said heart beat. From the factory, AVR internal oscillators are only accurate +/- 10%. If one calibrates it with the calibration register, you can get it within +/- 1%. Our heart rate is only going to be as accurate as our cpu frequency.

We also use a timer counter to detect when our signal goes away to alert the user they should go back in range.

Schematic

Schematic for Heart Rate Logger

Graph: heartrate log of jogging and walking

Source Code

I’m more than happy to share the source code just don’t have time to clean it up and post it unless it is worth it for you guys. There are no new core pieces here since I’ve already posted other projects that use interrupt pins, SD cards, fat filesystems, timer counters, etc.

* SD / MMC code from previous post

* FAT library from elm-chan.org

* parsing GPS sentences in software for status indications and space savings

* GPS data is logged to gpslog.txt on the SD card

This project shows the user of a simple thermistor to measure temperature and display the temperature graphically on a Nokia 3310 LCD. Thermistors are incredibly cheap (about 50 cents), and provide fraction of a degree accuracy. The Nokia 3310 Library originally written by CC Darmini was modified yet again, this time to use per pixel access while maintaining the ability to draw text.

Thermistor Project LCD Screenshot

Thermistor Up Close

Custom Development Board (but anything can be used)

Details

The temperature sensing is achieved with a thermistor. These are simple devices whose resistance changes based on temperature. There is an equation, the Steinhart and Hart equation, that allows us to calculate the resistance using constants provided in the datasheet. In our case, we’ve used the Vishay thermistor NTCLE100E3103JB0 because Sparkfun.com sells it. We make a simple resistor divider using a 10k resistor and read the resistance using an ADC pin on our AVR. The accuracy of the resistor is extremely important. Its value is used in our calculations. If you choose a similar resistor but without this exact value, be sure you change the code to reflect the resistor you are using.

Our good ole’ Nokia 3310 LCD is used again. We’ve modified CC Darmini’s LCD library again. Last time, we modified it to get per pixel access using a local pixel buffer. This time we realized that we needed to be able to modify the pixels just as we did before but don’t want to actually update the display until we are completely done. This is only a performance gain if you are writing a significant portion of the screen. The modified library already only wrote to the bytes that had be modified.

Lastly, the current temp is sent out over the serial port at 9600 for logging. The schematic does not reflect this because it is not necessary. We recommend the super simple FTDI breakout board to easily power and add serial over USB to any of your projects.

Schematic

Schematic - atmega8 with 3310 LCD and thermistor

Nokia 3310 LCD Pinout

Source Code and Firmware

avr-spiceduino-3310-thermistor.tar.gz

This project allows one to use a universal IR remote to control an AVR based Etch A Sketch.  For display, we use the Nokia 3310 LCD ($10 from SparkFun.com).  The Etch A Sketch functionality is simply the ability to draw in a straight line up, down, left, right.  The purpose of this project was to demonstrate the improvements to CC Dharmani’s NOkia 3310 library that allows per pixel access using a pixel buffer.  The improved version has been included in the source of this project *.  As originally written, the library worked great displaying fonts of two different sizes, clearing the screen, and drawing a boarder around the edges.  Because of the way one must talk to the screen, it did not allow raw pixel access or random drawing.  Doing so requires a local cache (buffer) of the pixels.  This way, if you want to set a single pixel, you have the old value that you set to modify and write it back.  The improvements shown here do just that.  Additionally, we also have included a small tool to allow a .pgm file to be converted to a header for a splash screen.  The additional routine to display the image is also included.

* Hopefully CC Dharmani and I will get together and put this library in a source repository to store continual improvements.

Details

For input, we use a 38kHz IR demodulating receiver.  These can be picked up for $4 at RadioShack or $0.75 on Digikey (parts list below).  Sparkfun.com also has a fancy one for $9.95.  For display, we use our handy dandy Nokia 3310 replacement LCD.  We talk to it using SPI.  The arrow keys on the remote move the cursor and draw a line as it goes.  The MENU or MUTE buttons swipe the screen.

Schematics

Schematic - atmega8 with 3310 LCD and IR sensor

Nokia 3310 LCD Pinout

Source Code

Steps for making splash screens (included as header files) with pgmtoheader.c:

• open a file that you want to display on your Nokia 3310 (black and white graphics are best) in GIMP or Photoshop
• resize to a height of 56
• use the thresholding tool to find a good value to use as the point between black and white.  You probably will have to slide it back and forth until you get a good image.
• stretch/resize to 84×56
• save as .pgm (raw not ascii)
• open a hexeditor (I use khexedit) and hack off the header portion (or modify the code to skip over it)
• compile pgmtoheader with ‘gcc -o pgmtoheader pgmtoheader.c’
• run the pgmtoheader program on it with ‘./pgmtoheader /path/to/file.pgm > splash.h’
• you can now #include “splash.h” in the 3310_routines.c and call LCD_drawSplash() to display it.