Howdy,

Thanks to a comment by YT2095 on my last post, I started thinking that I need to do more averaging to achieve a smoother graph.  It turns out that this is very simple to do as the Arduino sketch writes 30 BPM samples per line to the text file on the SD card.  I created a new script named parse-avg.pl to take the average of every 30 sample set.  This created a graph with less fluctuation:

This new averaged data is feed into filter.pl, and a much smoother graph is generated:

Here is a comparison with both on a the same plot:

So I think the plot of the filtered data now is much easier to interpret.  However, I need to verify that the data is actually still accurate.  I have basic Polar wrist watch receiver which I can use to benchmark.  It doesn't log BPM readings, so I will have to write down the reading 30 sec for a short test run (say 10 minutes).  Then I can graph the written-down wristwatch readings versus the hrmshield filtered data.

Cheers,

Drew

Howdy,

After being consumed with Raspberry Pi WiFi adapter testing the last two weeks, I'm turning my attention back to finishing my Arduino heart rate data logger project (which I've termed the hrmshield).  I'm really glad that I finally moved the project to a github repo before I was sucked into the Raspberry vortex.  It's much easier to recall what I was up too by looking through the commit log and also not having to look around my hard disk for the "current" version.  Here's the project repo:

https://github.com/pdp7/hrmshield

The main attraction is the Arduino sketch, hrmshield.pde, which melds together code from HeartSpark, OpenHeart and Adafruit Logger shield.  Following Eric Boyd's lead in his HeartSpark code, I try to only do the minimal amount of processing on the Arduino before logging to text file on the SD card

Here's the rough method I'm currently using to attach the hrmshield to my arm for test runs:

Since the data is "raw", I have been working on a set of Perl scripts that parse and filter the heart rate samples to generate accurate graphs.  These are in the repo as well, but I'm still working on improving the filtering scripts.  Also, I've been using an interactive GUI frontend to gnuplot called qgfe which while very handy for analyzing test data, but I need to write scripts with automate the process of running gnuplot.  I'll do post on this topic soon.

Also, once I've wrangled the filtering and graphing process, I really need to make a nice laser cut or 3d printed enclosure at my hackerspace.  For now, here's a video of my crude version in action:

Cheers,

Drew

Howdy,

I've finally placed the Polar chest strap receiver chip and Open Heart LED matrix on the Adafruit data logger shield:

Quick video while I'm sitting at rest:

The Adafruit shield has a SD card accessible via SPI and a DS1307 RTC via I2C.  I'm working on the code write now to log the heart rate data to the SD card and hope to have it done in a day or two.  I'll post it here then.  After that I'll try using gnuplot on a computer to make graphs of the data.

Here's a couple more shots of the shield.  I used female headers for the Open Heart and Polar chip as I wanted to be able to remove easily if needed.  The crystal for the Polar chip is actually soldered underneath the shield as I was at first thinking I would lay the Polar chip flat on the prototyping area:

Cheers,

Drew

Howdy,

I had a great time making SMD LED Christmas cards (which double as tree ornaments) back in December:

However, I only managed to make 3 out of 13 in time after parts and PCBs finally arrived.  My mom's birthday is today so a couple of weeks ago I decided I'd repurpose one of the remaining PCBs to make a musical Birthday card:

I found this card at Walgreens, and it seemed pretty fitting.  The speaker was scavenged from a different electronic Hallmark card.  I originally tried a couple piezo speakers I had in my parts bin, but it sounded much better.  The speaker leads are connected to the pads for one of the LEDs.  The board is designed with a series resistor connected to each LED.  I only had 390 ohms SMD resistors, and speaker was softer than I wanted with that resistance.  So I removed the SMD resistor, shorted that pads with solder, and then soldered a through-hole resistor between one speaker lead and LED pad.  I wish I would have taken a picture of the other side of the board as I'm having trouble remembering the value, but I believe it was 82 ohm.

I also soldered 4 LEDs onto the board to give a visual effect beneath the illustrated phone on the front of the card:

The LEDs and speaker are all controlled by the same AVR pin, so the LEDs blink in rhythm with the melody.  Unfortunately, only the yellow LED was bright enough to be seen through the card.  The tactile switch on the board is positioned under the bottom of the illustrated phone's keypad.  The Happy Birthday melody will play once when that switch is pressed, and then the chip will go to sleep until pressed again.

I used this source code from Nerd Kits as the basis for playing Happy Birthday:

http://www.nerdkits.com/videos/musicbox1/

However, I had to make some changes as it was written for an AVR ATtiny26 while my board uses a ATtiny13.  The challenge was to determine which delay value on the ATtiny13 generated an A5 note which is 880Hz.  I set the fuses so that that ATiny13 runs as 9.6MHz on internal RC with no clock divider.  If not already set, the fuses can be set via avrdude (note that I am using an Adafruit USBtinyISP programmer):

avrdude -c usbtiny -p attiny13 -i 5 -U hfuse:w:0xFF:m -U lfuse:w:0x7A:m

And, for reference, this is how I would compile the source code and program the AVR:

avr-gcc -mmcu=attiny13 -Os -o happycard.out happycard.c
avr-objcopy -O ihex -R .eeprom happycard.out happycard.hex
sudo avrdude -c usbtiny -p attiny13 -U flash:w:happycard.hex

The Nerdkits code uses the standard AVR libc delay functions to handle the timing of playing notes.  However, when attempting to use them in my ATtiny13 program, I ran into cryptic avr-gcc errors.  After some searching, I discovered this was an indication that I had run out of Flash memory to store the program code after linking that library.   I was surprised but the ATtiny13 is a minimalist part with only 1K flash memory and 64 bytes internal SRAM.

Thus, I decided would construct my own simple microsecond delay loop.  Unfortunately, I couldn't get the duration of my microsecond delay function below 1.23 microseconds (which I observed with my scope, the Rigol DS1052E).  While I may have been able to optimize it, I decided I would just modify the note definitions from the Nerd Kit source code to compensate.  I did so by copying the #define statements for the notes into a separate text file, processed with this perl one-liner and then copied the adjusted #define's back into the source code:

cat notes.txt | perl -ne 'chomp; ($a, $b, $c) = split(/ /); print "$a $b " . int(($c/.81)) . "\n";'

I then modified the source code to output just a single note, A5, and check the frequency with my scope (a DMM with a Hz function would also work).  I was within a few Hz of 880, so I was satisfied.

After adding all the notes back from the Nerd Kits code, I noticed the melody didn't sound quite right.  I looked up the sheet music for a happy birthday from a couple sources online and decided to adjust the duration of a couple notes accordingly.  I also added a brief break in between playing each note.  With these changes, the melody sounded much more accurate.

I've attached the source code, happycard.c, to this blog post.

Cheers,

Drew

http://twitter.com/pdp7

Howdy,

I've assembled several Velleman (http://www.vellemanusa.com) holiday kits over the last few years to give as gifts:

I'm glad they make such kits, and the prices are reasonable.  However, in the age of cheap microcontrollers, the fixed blinking LED patterns are a bit of let down after soldering a gob of LEDs.  In almost all the kits, transistors switch on and off strings of LEDs based on the RC time constant of the components.  Thus, I got the idea to hook up one of the kits to a microcontroller to add more pleasing variations.

I decided to give this a try with the Velleman 3-D Christmas tree:

http://www.vellemanusa.com/products/view/?id=351133

Thanks to RadioShack's recent DIY blitz, this kit is stocked in all 3 RadioShacks I've visited in Chicago recently.  This mod could have been done with any number of popular microcontrollers, but I thought I'd shoot for an Arduino-compatible setup given many folks are familiar with it (and I was bit tired of fiddling with registers after a recent pure AVR project).  I had an unused Breaduino kit (http://www.appliedplatonics.com/breaduino/) which is a breadboard-able ATMega328 Arduino clone I'd bought at Noisebridge (San Fransico's hackerspace).  I decided to use this as my goal is to solder all the components on a small protoboard to mount under the tree.  For now I've just setup the circuit on a breadboard with jumpers connected to the 3-D tree PCB:

The Arduino fades the LED segments in and out at different randomly-selected rates using PWM via the easy analogWrite() functions.  I found it quite pleasing to watch, especially in dim light.

Here's the schematic of the 3-D tree kit from the instructions:

http://www.vellemanusa.com/downloads/0/minikits/manuals/manual_mk130.pdf

I cut the positive lead on each capacitor and then connected a jumper to the "capacitor-side" of the 82k or 100k resistor for each of the 4 segments (for one segment I clamped on the negative lead of the capacitor as corresponding the resistor lead was too tight of a fit for the mini-hook jumper):

Those jumpers then are connected to pins on the AVR via 1K resistors.  Finally the 9V battery connector springs on the PCB are connected to the 9V rails on my breadboard (where a 9V battery is strapped on).  I will make a proper schematic when I get ready to solder components onto a protoboard, but, for now, here's my messy breadboard:

The 2nd breadboard really isn't needed, but I started off by breadboarding all the components which are now soldered onto the 3-D tree PCBs.  The Breaduino doesn't have a USB interface like an official Arduino board, so I used a FTDI USB-to-serial cable to program it.

Here is the sketch I wrote which is based on the PWM LED Fade example which is included with the Arduino installation:

// Arduino-mod for the Velleman 3-D Christmas tree kit
// This code is in the public domain (based on the Arduino.cc Fade example).

int fadeAmount = 0;
int fadeMax = 0;
int fadeMin = 0;
int fadeDelay = 0;

void setup()  { 
  //serial output isn't required, but useful when experiementing
  Serial.begin(9600);
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  randomSeed(analogRead(0));
} 

void loop()  { 

  // generate random setting to keep patterns interesting
  // bounds were determined by experiementation, so you
  // you may want to tweak to your own liking
  fadeMin = random(1,100);
  fadeMax = 255;
  fadeAmount = random(1,10);  
  fadeDelay = random(5,15);    

  // this loop controls the duration for each random pattern
  // note, the faster the fading, the sooner the pattern will end
  // maybe this could be improved by refactoring the program to be 
  // driven by a timer interrupt so each patttern gets equal duration
  for(int i=0; i<20; i++) {

    Serial.print(i);
    Serial.print("\t");       
    Serial.print(fadeMin);
    Serial.print("\t");       
    Serial.print(fadeMax);
    Serial.print("\t");       
    Serial.print(fadeAmount);
    Serial.print("\t");        
    Serial.println(fadeDelay);  

    // fade from minium to maximum brightness
    for(int fadeValue = fadeMin ; fadeValue <= fadeMax; fadeValue += fadeAmount) { 
      analogWrite(11, fadeValue);
      //invert the current brightness so that LED segments visually "oppose" each other
      analogWrite(10, fadeMax-fadeValue);
      delay(fadeDelay);   
    } 

    // fade from maximum to minimum brightness
    for(int fadeValue = fadeMax ; fadeValue >= fadeMin; fadeValue -= fadeAmount) { 
      analogWrite(11, fadeValue);          
      analogWrite(10, fadeMax-fadeValue);              
      delay(fadeDelay);                            
    } 

  }

}

Now that I have a working prototype, I look forward to permanently placing the components on a board attached to the base of the tree to make an attractive holiday decoration.

I'd love to hear about what other holiday-themed electronics projects folks have been working.  Please post in the comments if you've got anything to share.

Happy Holidays!

Drew

http://twitter.com/pdp7

               Ken Thompson and Dennis Ritchie (source: Wikipedia)

I was very sad to read a post from Jon "Maddog" Hall yesterday evening revealing the news that Dennis Ritchie has passed away at the age of 70.  Ritchie created the C programming language and was the co-creator of Unix with Ken Thompson at Bell Labs.  The influence of the technologies he created is so widespread that it is difficult to communicate the magnitude.

Ken Thompson (seated) and Dennis Ritchie (standing) at a PDP-11 in 1972. (source: The Art of Unix Programming)

My first exposure to Ritchie was when my father (who spent his whole career at Bell Labs) brought home the famous K&R C book for me when I was in 8th grade.  Over the previous couple years, HyperCard on my Mac had piqued my interest in programming, and I was ready to move onto something more mature.  I've always enjoyed using C ever since, and some of my favorite programming experiences have been with C: learning the Win16 API (when I was young), the POSIX API (when I grew wiser), trying to write Linux kernel modules (didn't really pan out), and tinkering with embedded systems (which I try to make time for every night).

(source: Wikipedia)

Rob Pike, long-time Bell Labs researcher and colleague, has made some poignant posts to Google+ including one highlighting the most important email he received from Ritchie (aka dmr).  I've been reading through various coverage and found Fred Gallagher of Ars Technica really captured the importance of Ritchie's work in his Wired article:

By creating C, Ritchie gave birth to the concept of open systems. C was developed so they could port Unix to any computer, and so that programs written on one platform (and the skills used to develop them) could be easily transferred to another.

In that way, Ritchie has shaped our world in much more fundamental ways than Steve Jobs or Bill Gates have. What sets him apart from them is that he did it all not in a quest for wealth or fame, but just out of intellectual curiosity. Unix and C were the product of pure research - research that started as a side-project using equipment bought based on a promise that Ritchie and Thompson would develop a word processor.

Imagine what the world would be like if they had just stuck to that promise.

Thompson (left) and Ritchie (center) receiving the National Medal of Technology from President Clinton. (source: Wikipedia)

Finally, I just came across this golden clip of Ritchie and Thompson talking about Unix in what looks to be the 70s - fascinating!  Doug McIlroy makes an appearance, too (he invented pipes!):

Code in Peace, Dr. Ritchie.

Sincerely,

Drew Fustini

http://twitter.com/pdp7

In a new post from Evil Mad Scientist Laboratories, the clever idea of visual diffs for schematics and board layouts is explored:

GitHub now automatically supports visual diffs for image files included in commits. What this means is that if you (as a designer) generate and include an up-to-date PNG version of your schematic and layout in every version and commit there, you will also automatically generate a matching visual-diff history of the project. This is potentially huge -- if the open source hardware community will step up to the plate and take advantage of it.

http://www.evilmadscientist.com/article.php/visdiff

Cheers,

Drew

http://twitter.com/pdp7