They often say the best projects are those that scratch a personal itch.  At Manifold we are a passionate bunch.  Our personal passions often bleed into the work we do and our latest pet project is no exception.  I’ve spent the better part of the last 5 years training for one endurance event or another.  Mostly cycling, but this year I’m focused on triathlons, specifically Ironman.  This has meant a lot more running than in past years (about 800 miles so far and counting).  Along the way I’ve read more articles on proper running form than I can recall.  One constant theme jumps out over and over again; cadence (a.k.a.) stride rate, revolutions per minute (rpm), leg turnover, etc. Studies of elite athletes have shown that a faster cadence  leads to increased speed and endurance as well as less injury caused by things like over-striding.  Many articles quote a magic cadence number of 180 strides per minute (90 per foot) as being the perfect target.  This comes from Daniels’ Running Forumla, a book written by legendary distance running coach Jack Daniels.  The 180 target is not without debate.  Some would say that’s the minimum and others would say the number is dependent on the unique physical characteristics of each athlete.  So while everyone may not agree on the number most would agree that cadence is important.  You should understand what your cadence is and work to improve it.  Lets put aside the debate on what the number should be and focus on how we measure our cadence.  After all, if we can measure it then we can improve it.

There are plenty of devices aimed at measure cadence on a bike.  Most commonly it is a simple magnet attached to the wheel with another stationary part that sits on the bike frame.  The bike computer tracks the number of times the magnet passes the stationary part per minute.  Unfortunately, in the running world devices like these are not so common.  Most good running watches are capable of tracking cadence with the addition of a footpod device.  However, the vast majority fail to display this information in real-time.  If they do track cadence then most often they only expose the average cadence or provide an alarm feature that triggers when you are above or below a user defined threshold.  Average cadence is great for reviewing you run after the fact, but what about being able to adjust your cadence in real-time.  The longer your run the harder it is to move the average.  In the perfect world what you’d have is real-time cadence during the run and an average after the run.  Imagine you just returned from a 2+ hour run and upon review realize that your cadence was way too low.  Too late to do anything about it.  Better luck next time!  Some would suggest you manually count the number of steps taken with 1 foot for a minute and multiple that by 2.  Others suggest using a metronome or an MP3 to help keep you on track.  Try doing any of those on a multi-hour run day after day and you’ll drive yourself crazy. There has to be a better way and that is the real point of this post.  We’ve been known to dabble in hardware hacking from time to time and have been looking for a reason to explore the world of wearable computing for a while.  We decided to prototype a hardware device that was capable of tracking real-time running cadence.  Our name for this device is Striker.  The rest of this post will focus on how we built Striker and how you can take and learn from what we’ve done.  We’ve open-sourced all the code,  3D models, and provided fritzing sketches for the hardware wiring.  You’ll find links for all of these at the end of the post.

1st Generation – Basic Prototype

As I mentioned above, we planned on using this project to explore wearables and dive deeper into the world of Arduino and Arduino like single-board microcontrollers.  Our initial take on this was to build a running suit of sorts with an armband display that could be connected directly to the running shoe.  We wanted to prove the idea before getting too deep into the final design.  I am not going to spend a of time talking about the 1st generation prototype, but here is a quick overview and a short video of it in action.  There are 2 parts to the design; the shoe & the wristwatch display.

The Shoe

To detect the foot strike we utilized a force sensitive resistor (FSR).  The FSR is placed inside the running shoe and its connectors are pushed out a small hole on the side of the shoe.  For the initial prototype we simply ran wires from the FSR directly up the side of the body to the wristband and used small clothes pins to temporarily secure the wires.  Soldering directly to the FSR tabs is not a simple task so we actually used a terminal connector as described in this Adafruit tutorial.

Shoe Parts

The Watch

The 1st generation wristwatch design utilized an Arduino Uno, a 4-Digit 7-Segment Display, a round PCB, a 10K resistor (for reading from the FSR), and a basic AA battery pack holder.  These components were mounted on a piece of craft foam paper that was sized to wrap around a forearm.  Strips of velcro where used secure the foam paper around the forearm.  The Arduino continuously reads the FSR and monitors the amount of pressure detected.  The theory was that it should be pretty easy to tell the difference between a foot strike (massive pressure) and foot in mid-stride (little to no pressure).  As it turns out the first assumption is true.  However, the 2nd part is a little more tricky.  Just because the foot is not on the ground doesn’t mean there is a lack of all pressure.  Pressure still exists because the foot is tucked into the shoe fairly tightly and a runner’s foot moves around during a stride.  This is not a huge deal it just makes determining an actual foot strike a little more complex.

Generation 1

Here is a video of the first prototype in action:

2nd Generation – Research & Key Learnings

The 2nd generation was mostly about research and experimentation.  We spent time thinking through all the various parts included in the build and how we could shrink them and/or remove them completely.  Initially, keeping with the running suit idea, we thought the Arduino Uno should be replaced by another Arduino board.  Something smaller, lighter, and better suited for wearable products like the LilyPad or the SquareWear.  Lilypads can even be washed which gave them a slight advantage since one is likely to sweat while running.  We also anticipated replacing the long wires seen in the 1st generation with conductive thread.  This would have allowed for a less visible and more seamless connection between the wristwatch and the shoe.  The 7-segment display worked, but it was bulkier than it needed to be and limited the amount of information that we could display.  We also thought about how to replace the foam paper.  Initially we had settled on a sweat wristband because we figured it could be easily disconnected from the suit and washed.

As time grew on we got more and more ambitious.  While we really wanted to do something with a Lilypad and conductive threading we ultimately decided that was better saved for a future project.  This project has 2 distinct components and they should really be decoupled from one another.  This meant removing the wiring between the 2 parts completely as well as giving each part its own power source and brain.  It was at this point that we also decided to make the wristwatch actually look more like a sports watch instead of forearm wristband.  We got to work on a 3D model for the watch and began pumping out physical prototypes using the MakerBot Replicator 3D printer we have in our lab.

2nd generation

With the wires removed we needed a wireless method for sending data from the shoe to the wristwatch.  We started with bluetooth, but in the end settled on using 2 Xbee modules.  Xbee modules are a great way of adding wireless connectivity to a hardware project.  I won’t cover the setup or usage of them in this article.  There are a number of good tutorials on the web and we found this book to be extremely helpful.


The new wristwatch design also meant less space to work with.  So the next trick became finding the right mix of components to fit within the new wristwatch housing.

3rd Generation – Refinement & Miniaturization

The bulk of time for this project was spent working on the 2nd generation.  We never fully completed the 2nd generation design because we decided on a few more changes along the way.  The end result is the 3rd and final generation that I am about to describe.

We decided to replace the 7-segment display with an OLED display so that we could have more control over the presentation of the cadence data.  While replacing the OLED display we also thought about how we could improve the display housing.  Traditional PLA filament results in a hard plastic surface.  Not that this was a super bad thing, but this meant that the enclosure was very stiff.  We would have preferred something more flexible/rubbery like a traditional sports watch.  It was then that we discovered NinjaFlex and Adafruit’s related FLORA wrist band project.  We then reworked our 3D model to account for the new OLED display and integrated the actual watch band into the design (much like the FLORA project).  At this stage we also developed a new 3D model for what would eventually mimic a standard footpod and be attached to the laces of the running shoe.

Final Hardware

Here is the parts list for the wristwatch:

  1. Sparkfun Pro Mico (5v/16MHz) – This is a very small micro-controller.  It fits neatly inside our watch enclosure.  It is not an official Arduino board, but it is Arduino compatible.  That basically means you have to do a little extra setup before you can program it via the Arduino IDE.  The process is pretty straight foreword.
  2. 850mAh Lithium Ion Battery
  3. Power Cell (Lipo Charger/Booster) – Our battery outputs 3.7V.  The Pro Micro board requires a 5V power source.  The power cell is used to boost the 3.7V output to 5V for the Pro Micro.  The battery hooks into the power cell using a standard JST connector.  The power cell provides a convenient micro-USB connector that can be used to charge the battery.  We expose this connector on the side of the enclosure so that the watch can be recharged without removing the lid.
  4. SPDT Mini Power Switch – The on/off switch exposed on the outside of the watch enclosure.
  5. Monochrome 128×32 SPI OLED graphic display – This is a great little OLED display.  Adafruit makes it pretty easy to work with as well via their libraries and tutorials.
  6. XBee 2mW PCB Antenna (Series 2)

Here is the final parts list for the footpod:

  1. Fio v3 (ATmega32U4) – This is another Arduino compatible micro-controller produced by Sparkfun.  It is very similar to the Pro Micro used in the wristwatch.  Again there is some light setup, but that’s covered in the same guide linked to above.  One great feature of this board is that is has a XBee socket built right in.  This eliminates the need to wire up the XBee separately and find a way to secure it inside the enclosure.  It only requires a 3V input and it has an integrated LiPo charger eliminating the need for something like the power cell used in the wristwatch.  The main reason the wristwatch uses the Pro Micro over the Fio is size.  The Fio is not big by any means, but it is longer than the Pro Micro and we did not want to enlarge the watch enclosure to accommodate it.
  2. 110mAh Lithium Ion Battery
  3. Force Sensitive Resistor
  4. Terminal Block (2-pin 3.5mm)
  5. XBee 2mW PCB Antenna (Series 2) – Same as the wristwatch.  These modules were paired to speak with each other.

Here is a picture of the hardware setup during the breadboarding phase:


End Result

We knew given the time and resources we had for this project that we’d never get Striker down to the size of a commercial sports watch, but our goal was to keep it roughly in the same ballpark.  We managed to pull that off reasonably well.  Below are side by side comparisons of Striker to a Garmin 910XT & the Striker footpod to a Garmin footpod.

watch sidebyside

footpod sidebyside

Here is a video that details the final design and provides a demo of the device in action:

At the end of that last video the demo show a current cadence of 86.  As a sanity check of the results I wore my Garmin 910XT on the other wrist and my Garmin footpod on the other shoe.  I turned the Garmin watch on a little late during the test so I am not going to the compare average cadence of the 2 devices.  However, if we compare the average cadence reported by Garmin to the current cadence reported by Striker for the last minute of the run we can see the results are very close.  Within  1 foot strike of each other (174 / 2 = 87).

garmin cadence

This was a fun and challenging project.  We certainly learned a great deal in the process.  Striker will remain in the lab for now, but hopefully something like this will become more readily available for runners everywhere.  As wearables become more popular and more advanced this problem should actually get easier to solve.  Companies in the sports watch business should be doing a better job of exposing this information already.  As far as a custom solution goes, rather than inventing a watch to receive and display the cadence data it would actually make more sense to build an app for an existing watch platform like Samsung Gear, Pebble, iWatch, etc.  Then all you need is a footpod capable of detecting foot strikes and sending the data along using a communication protocol that the watch platform can speak like bluetooth.

 Build Your Own?

So you want to build your own?  OK we got you covered.  Below you’ll find links to the Arduino code (released under the BSD license), the 3D models, and some fritzing sketches for your reference.  If you build your own or make any further improvements we’d love to hear about it.

Arduino Code Repositories:

Fritzing Breadboard Sketches:

The sketch files are included in the code repos listed above.  Exported images are also shown below for reference.

breadboard sketch

breadboard sketch

3D Models:

The 3D models for all the various parts of this project have been shared on Makerbot Thingverse.