On Saturday I stopped by the Apple store and picked up an UP device by Jawbone. The UP is a wristband and iPhone app that will track your fitness and sleep activity and help encourage you to live a more active life style. It’s very similar to the Fitbit device, and lets you track:

• steps
• distance
• calories burned
• active/inactive times
• workouts
• sleep (awake/light/deep sleep)

So far I’m really impressed with both the wristband and iPhone app.  However, I was a little disappointed the wristband didn’t support ANT or Bluetooth for data synchronization.  The data sync is unique and “low impact” (battery-wise) in that it plugs into the iPhone via the headphone jack and uploads data directly to the app. After some digging I was surprised to see no way to send or save the data.  I was curious if the data was just saved to the app, or also synchronized with another server.

As with most of my Quantified Self gadets (Fitbit, Zeo, Withings, Neurosky, etc.) my first reaction was to “free my data”.  My understanding is that Jawbone has exposed an API to partners, and will soon be releasing a more public API and ability to download data shortly.  Similar to my initial journey with the Fitbit, I was inspired to find an “unofficial” way to get access to the data (e.g. my Fitbit Hacks).  I was able to get access and save my personal data for about a year before an official method became available.  Luckily Fitbit and other companies like Zeo (especially Zeo) have taken an open approach with their APIs and have embraced the developer community.  My hope is that UP will do the same.

In the spirit of filling in the data gaps until that day comes and an official announcement is made I decided to do a bit of exploration yesterday morning.  Using my favorite HTTP/SSL sniffer (Charles) and some tinkering with the app I was able to decipher how to get access to all of the UP data.  I haven’t written a data scraper script yet, but I was able to verify a number of API requests from the command-line using LWP POST and GET.

I wrote up some detailed notes in my wiki yesterday and have posted a snapshot here:

Jawbone UP API – http://eric-blue.com/projects/up-api/

My hope is this should give others enough information to download their own data for the purpose of backing up and analysis with other software.  Since this isn’t officially supported and appears to be used only by their app I would use sparingly (no excessive requests) and don’t do anything that would violate a TOS/AUP (use at your own risk).  Otherwise, enjoy!

My other Quantified Self-related projects:

TRAQS.me (Tools for Reporting & Analysis of the Quantified Self)

Fitbit Hacks (the original “unofficial” API)

Zeo (Hacking your way to a better night’s sleep)

NeuroSky Brainwave Visualizer

Mindstream – Neurosky EEG Data streamer

For whatever reason, at home I’ve been primarily sticking with a single monitor.  I use Ubuntu and natively use virtual workspaces, but still doesn’t give me the screen real estate that a 2nd monitor provides.  Rather than invest in a 2nd monitor right now, I thought it would be pretty slick to use my iPad as a second “virtual” monitor.  It turns out this is possible AND very easy!

What is a virtual monitor?  Through the magic of VNC i can actually use all of my apps on my main Linux PC and at the same time add touch screen support!  What do you need?

• A computer (PC, Linux, or MAC) with some VNC server installed and a VNC viewer.  I don’t really have a preference on VNC software, but you can check out RealVNC (http://www.realvnc.com/)

• An iPad running some VNC-capable software.  I haven’t researched extensively but I believe there are a number of solutions.  The app I’ve been running for years now is iSSH.  iSSH is sophisticated terminal software that is capable of SSH and support VNC connections.

• A nifty iPad stand that turns your iPad into a swivel monitor (OK, this isn’t needed, but puts some icing on the cake).  I’d recommend the RocketFish iPad Stand.

How do you set this up?  Easy…

1. You can opt to control your PC with VNC like most users do.  However, if you want a real “virtual” monitor/desktop you’d want a distinct workspace.  By default VNC uses :0 (your main desktop) as it’s default display.  You can create a new VNC server instance on a fresh desktop at :1.  I’m using TightVNC so the syntax may vary, but the command to setup is easy:

vncserver -alwaysshared :1

AND to kill the isntance when your done or want to start over

vncserver -kill :1

Note: the -alwaysshared is needed if you want to also control the iPad “virtual” monitor from your main PC

2. If you haven’t done so download and install iSSH from the App Store (currently $9.99 USD).  Setup either an SSH with VNC, or Raw VNC connection to your main computer.  Make sure to specify :1 as the port.
3. If you want to also control this new iPad virtual desktop from your main PC you can run vncviewer. On the command line (assuming Linux) run:

vncviewer :1

Note: You should see this display mirrored on your iPad as well.  You now have the choice to control exclusively from the iPad or share from the main PC.

Here’s a screenshot of my iPad monitor setup using the RocketFish stand and running Firefox from my iPad.

README

# Author: Eric Blue
# 	url   = http://eric-blue.com/
#   email = ericblue76 (at) gmail (dot) com
# Project: Neurosky Mindstream - System tray app to stream EEG data 

[Overview]

Mindstream is a simple java-based system tray app that streams EEG brainwave data from
NeuroSky devices (MindWave,MindSet).  The app interfaces to NeuroSky devices using the
ThinkGear Socket protocol (connecting on localhost:13854), retrieves data in JSON
Format, and can "stream" to other applications.  Mindstream can save the following
data:

	* Focus levels
		- attention
		- meditation
	* EEG values
		- delta
		- theta
		- lowAlpha
		- highAlpha
		- lowBeta
		- highBeta
		- lowGamma
		- highGamma
	* Headset signal strength
		- poorSignalLevel

Streaming functions will include:

    * Saving EEG data to a CSV File
    * Listen on a socket and replay data from localhost:13854
    	- allowing other applications to connect
    * Broadcast to a URL - supporting POST/M-POST and streaming real-time data
    	- future use? Processing Javascript version of the
                Neurosky BrainWave Visualizer
    		http://eric-blue.com/2011/07/13/neurosky-brainwave-visualizer/

[Current Status]

- Alpha state
- Streaming only supports writing to a CSV file
- Tested on Linux and Windows with Java 1.6 and the MindWave headset

I stumbled across a VERY cool hack ‘How to Hack Toy EEGs‘. As much as I eventually want to tinker around with some soldering and Arduindo hacking, this was a little more in depth with time permitting.  The key takeaway from this article was a very impressive Processing-based visualizer to grab data from the custom serial interface and display in real-time.  With relatively little work I was able to fork the version of code and interface with the Mindwave using the official ThinkGear Socket Protocol.  I also generated builds for Windows, Linux, and Mac so anybody can download and install. You can check this out at https://github.com/ericblue/Processing-Brain-Grapher.

Here’s the README with some more in depth info:

[Overview]

After purchasing a Neurosky Mindwave EEG device, I was surprised to see limited apps for
viewing and visualizing EEG output (brainwave activity for delta, theta, alpha,
and beta waves). Upon discovering 'How to Hack Toy EEGs'
(http://frontiernerds.com/brain-hack), I was
inspired by the Processing visualization of the Arduino-based serial output.
I wanted to visualize the same set of data, however decided to obtain it using
Neurosky's published ThinkGear Socket Protocol
(http://developer.neurosky.com/docs/doku.php?id=thinkgear_connector_tgc).

This fork of kitschpatrol's original code differs in that it doesn't use the
Serial interface to obtain brainwave data.  Rather, it communicates via the ThinkGear
connector using the ThinkGear Socket Protocol and requests data in JSON format.

[MindWave/MindSet Communication]

By default the ThinkGear Connector allows applications to connect over TCP
(default 127.0.0.1:13854) and request data in either binary or JSON format.
This application will connect to the ThinkGear socket,
and read the streaming real-time data.  Format:

	{
	"eSense":
		{"attention":91,"meditation":41},
	 "eegPower":
	 	{"delta":1105014,"theta":211310,
	 	"lowAlpha":7730,"highAlpha":68568,
	 	"lowBeta":12949,"highBeta":47455,
	 	"lowGamma":55770,"highGamma":28247},
	 "poorSignalLevel":0
	 }

The default IP and port will be used, unless alternatives are specified as
environment variables (THINKGEAR_HOST and THINKGEAR_PORT).  Port forwarding can
be used on the host Windows or Mac computer to allow remote servers to connect.
To allow other hosts to connect and run Processing, run ReplayTCP
(http://www.dlcsistemas.com/html/relay_tcp.html) OR, use netcat (windows or mac)
to port forward (clients can now connect to port 13855).
Ex:  nc -l -p 13855 -c ' nc localhost 13854'

[Required Libaries]

The following required libraries are included:

- ControlP5
- JSON (See http://www.blprnt.com/processing/json.zip)

[Binaries]

Binaries were creating using Processing's app builder
(platforms = windows, mac & linux)

[Todo]
- Re-visit previous todo from original code
- Add ability to record data (CSV, etc.)

Devices like FitBit make syncing and importing data relatively fast.  As soon as the device syncs with the ANT-based station, data is uploaded to the FitBit site and this can be easily extracted.  However, for Garmin devices like the FR60 heart-rate monitor, extracting data from the Garmin Training Center product is a manual process.  You have to manually launch the app, go to Export, and save your data as a .TCX file.

You can pick and choose each activity to export (tedious), or you can save the entire data (a larger file ~ 15MB of data now) which takes some time to save and process.  This is clearly less than ideal.  In an effort to have my data INSTANTLY imported and available, I spent some time researching ways to accomplish this.  The hacker in me was thrilled when I discovered a linux-based open source project called GarminTools.  From the project page:

“This software provides Linux users with the ability to communicate with the Garmin Forerunner 305 via the USB interface. While this is the only Garmin unit that I own, I did implement all of the documented Garmin protocols as of Rev C (May 19, 2006) over the USB physical link. This means that if you have a Garmin with a USB connection to a PC, you ought to be able to use this software to communicate with it.

If you’re looking for a complete solution to all of your Linux Garmin GPS needs, this is not it. I own a Garmin Forerunner 305 and wrote this code specifically so I could download and save data from that particular GPS unit to my Linux machine. I tried gpsbabel, but found that it did not have command line options specific to the Forerunner run and lap data – all I could do was get the tracklog. That’s how all of this got started. I also wanted a few other things, like the ability to convert a track log into a Google maps encoded polyline, and (eventually) the ability to generate PNG images of heart rate and elevation data.”

I’m going to eventually dig deeper into this project, but since my time is more constrained this weekend I opted for a more pragmatic (ok cheap) hack.  I discovered that the Garmin Training Center app stores individual TCX files each time you sync under a folder (on Windows 7) like:

C:\Users\username\AppData\Roaming\GARMIN\Devices\1110044\History

I figured a simple approach would be to sync this folder with my server, find any files newer than the last imported Activity/Heartrate data, and process.  A simple windows share could have sufficed, but I figured it might be easier just to sync with Dropbox and make the data available from any of my computers.  So, here’s the quick n’ dirty recipe:

1) If you don’t already have an account, signup for Dropbox and install clients on your computer running Garmin Training Center, and where you ultimately want to send your .tcx files.

2) After your Dropbox folder is setup and you’ve done a simple test to verify sync works, you’ll want to share this folder.  Now, I’m sure there’s an easy way to share folders OUTSIDE of the Dropbox folder, however 1 minute of Googling with no luck made me look for another option.  On Windows-based machines you can actually do the equivalent of a Unix symlink using the Junction program from sysinternals.  Here’s how to set it up:

• Download and install Junction from the URL (you can copy the junction.exe file to c:\windows\system32)
• Go to the command prompt (cmd), cd to your Dropbox directory, and run:
• c:\windows\system32\junction GarminHistory C:\Users\username\AppData\Roaming\GARMIN\Devices\1110044\History
• Do a directory listing and verify the new GarminHistory folder exists under Dropbox and syncs properly

3) Go to your destination server where Dropbox is installed and presto, you have all of your workout/activity/heartrate data available in .TCX format!

Since last August when the project was originally envisioned, I’ve made a lot of progress on not only building this system for my own use, but also expanding on the original idea of just ‘tracking fitness’.  Fitness is one significant component of improving oneself and general well-being.  But, when most people think of fitness, it’s associated with simply going to the gym, running on the treadmill, or pumping iron indoors, and tracking these activities in some journal.  The scope of my project has since grown to include tracking for sleep quality, detailed location tracking and geocoding, and heart rate monitoring.  I’d like to eventually expand the scope further to include nutrition tracking, health metrics (blood pressure, nutrient levels/blood tests, cholesterol, etc.), and even more subject things like mood and factors that affect emotional well-being.

With this in mind, my personal project has evolved into a more general purpose tool for tracking and analysing data related to the Quantified Self.  Hence, my new project name TRAQS.me (Tools for Reporting & Analysis of the Quantified Self) or simply put, it’s a tool that (Tracks “Me”).  I’ve put together a slideshow/presentation that gives a decent overview of the entire project:

In Dec ‘09 I shared a blog post about how to synchronize the scrapbook data between multiple computers. This was the first major step to sharing data between multiple devices, but still lacked some of the ubiquity that I desired.  In a nutshell I’ve made 2 major enhancements to Scrapbook:

1. An email ‘bridge’ to Scrapbook so I can email links from any device (PC, iPhone, iPad) and have them saved by Scrapbook
2. A centralized web-interface to browse/search/filter my scrapbook data.

I’ll start off with the less visually-stunning hack (email bridge), but by far the craftier of two.

Hack #1 – Scrapbook Email Interface

Whenever I began synchronizing my Scrapbook data between the 2-3 computers this solved a huge problem with being able to save webpages from anywhere.  Since 2009 a lot has changed, and devices like iPhone and iPad (yes, Apple fan boy to a degree) have changed the way we consume news.  Recently I’ve been using apps on the iPad like Zite and Flipboard to consolidate my Twitter, Facebook, and Googler Reader feeds into a single personalized newspaper.  This means that now > 50% of my reading time is spent from a device that has no visibility into my Scrapbook data.  I simply wanted a way to automatically email a link (built nativily into these apps) and have it automagically saved into my Scrapbook folder.  I could have simply cut corners and wrote a script to hand-edit the Scrapbook RDF Files and save the web page using something like wget or curl.  But, it just wouldn’t be the same…. I want the webpage saved EXACTLY as Firefox would normally render and save it.

This poses a bit of a technical challenge, since Scrapbook runs inside Firefox and there’s no native way to interface with a plugin running inside a browser.  After researching a number of approaches, I came across 2 Firefox plugins that let you build interfaces inside firefox (http, telent, etc.) that actually let you control the browser and execute Javascript.  Of the 2 plugins; POW and MozRepl, I decided to go with POW (Plain Old Webserver).  Both plugins are wicked cool in the sense that they’re non-traditional and very powerful.  POW runs a webserver inside firefox and let’s you run your ’server-side’ scripts as Javascript.  I’ve basically written a server process that runs INSIDE the client and executes XPCOM/Javascript to control the web browser windows and invokes the Scrapbook plugin API directly.

The setup process is simple:

1. Setup and install the POW and Scrapbook plugins in your browser
2. Configure POW to run a desired port and create a new directory /scrapbook/
3. Copy the index.sjs (server-side javascript) to this new /scrapbook/ directory
4. Setup a new email box or alias (e.g. yourusername+scrapbook@gmail.com)
5. Either run scrapbook2email.pl manually or run as a CRON job every couple minutes
6. Simply send emails to your new Scrapbook email, run the email script, and watch your pages be saved automatically

At a high-level this is accomplished with 2 scripts:

Email Interface script (Perl)

This script uses IMAP to retrieve scrapbook email requests from a designated folder. Along with doing basic sender/recipient validation, the script is also aware of plain text/multipart messages.  Once the email request is parsed, the link of the requested web page to be saved will be extracted.  Given the request URL the script will then contact the POW server and pass the requested URL (e.g. http://127.0.0.1:6670/scrapbook/?url=http://yourwebpagetobesaved.com/?articleID=3q4e3332).  Note that this version of the script requires that Firefox/POW be running and makes no attempt to launch for you.

For a copy of the script click here (GitHub).

Scrapbook/POW Bridge (Server-Side Javascript)

This script does the heavy lifting, and is essentially running at the other end of the POW server URL (http://127.0.0.1:6670/scrapbook/). Once the requested URL is detected the browser will spawn a new tab, automatically execute the Scrapbook Capture request, and save the webpage to a new top-level folder (e.g. Unfiled/MM-DD-YYYY). This script was tested with Scrapbook v.1.3.7.

For a copy of the script click here (GitHub).

It’s nifty now to email a link to my Scrapbook Bot and wihin a couple minutes a little notify popup shows in Firefox indicating my page was saved.

Hack #2 – Scrapbook Browser

This code was actually written back in Dec ‘09 after I wrote the synchronize blog post (and around the time I wrote the Document Viewer), however I haven’t shared until now.  What I’ve done is write a simple Perl/JQuery web app that used Simile’s Exhibit to view Scrapbook data in a tile, table, or timeline.  This interface also has a file/folder view so you can browse snippets just like you can through the native Scrapbook plugin interface within Firefox.

Here are some screenshots:

Tile View

Timeline View

Table View

Folder View

To download the code click here (GitHub).

What’s Been Done So Far?

If you look at the original diagram I created, there where a few different components to this tracking platform (local storage, data collection scripts/api integration, and the presentation layer).

• Local Storage – Personal copy of data stored in MySQL.  I created the local storage piece almost immediately after writing the article in Aug.  I chose to use MySQL as a database, and created a schema that was suited towards collecting my initial data set of interest: data from my FitBit and WiThings scale.  The schema accounts for storing both daily and intraday activity for calories burned/consumed, activity score (+very active, moderately active, and lightly active), total distance, steps taken, sleep, and weight.  I’ve now created about a dozen or so SQL queries that will generate useful reports on this historical data.

• Data collection scripts/API Integration. I immediately leveraged the Perl FitBit API I originally wrote last April to sync data from the FitBit site to my local database.  I created a nightly cron job that will request the daily + intraday stats and save to the db using Perl::DBI.  I also took a similar approach with the WiThings scale.  Although I haven’t created a Perl wrapper yet for Withings, they do publish and easy to use REST API for getting access to your weight.  This script also runs on a nighly basis and saves weight information to the local database.

• Presentation Layer.  This has been the most complicated piece so far.  I’ve created a Java-based webapp using Spring 3.0/Jetty to build the analytics UI.  For now the UI is built with 2 major views: a dashboard, and reporting interface.  The dashboard displays both historical and daily information in a visually-pleasing format using Google Charts.  You can see a daily snapshot (+ weekly, quarterly, and yearly views) and see stats on your activity, distance, steps taken, weight, sleep and intraday stats (activity and sleep level on an hourly basis).  I’ve also built a light home-grown reporting interface that integrates with the Google Visualization API and easily builds dynamic tables and charts based on the provided SQL queries.

Screenshots

• Dashboard View

• Historical Stats – Multiple Activity Logs

• Historical Stats – Distance Bar Chart

• Daily Stats

• Intraday Stats

• Reporting

Immediate Next Steps?

The current code is fairly stable and mostly ready for a demo.  Before I make it live I’m planning on adding a few major features:

1. Geo-Location support – I’ve been tracking GPS coordinates since I purchased my QStarz device in September.  I’m thinking of adding a couple Map and GPS tracklog views to the Dashboard.  And, this could lead to some interesting location-based reporting as well.  I have a ton of saved .gpx files, so it’s a matter of writing an integration script to parse and store in the db.  And, some lightweight presentation layer to dynamically generate .KML and overlay on top of Google Maps.
2. Simple mobile interface.  I’d like to be able to access the interface using my iPhone and having some light interface to get quick stats and graphs would be nice.
3. Come up with a catchy project name.  As I stated earlier, although the original scope of this was for fitness tracking, this type of platform can be used for tracking any type of personal statistics.

Future Roadmap

1. Tracking detailed sleep info from MyZeo.  Since I wrote the original vision I had the chance to do a review for the MyZeo sleep device.  I’ve also created a Perl API so it’s simply a matter of writing the integration script to start recording in the MySQL DB.
2. Tracking workout info from my iPhone app – iFitness.  I also have about 10 years worth of workout information either stored from previous products (like CrossTrainer) or written down.
3. Tracking heartrate info from my Garmin heartrate monitor watch.
4. Integrate with the new official Fitbit API.  Since I wrote my initial (unofficial) Perl API, fitbit has embraced the developer community and released a support API (yes!)

1. Find an alternative to iTunes that let’s me access ALL of my music on the go with a low barrier to syncing/listening
2. Cleanup my music collection (meta tags, filenames, etc.) since my iTunes use (abuse) has left many songs forgotten and neglected
3. Free my Music… while I’m in the mood to completely ditch iTunes I might as well get rid of all my DRM-protected music.  I’m doing this for both philosophical and practical reasons.

SubSonic (http://www.subsonic.org/)

Subsonic is an open source music (free) java-based streaming server for Windows, Mac, and Linux.  Right of the bat, I have to say it’s one of the most impressive open source apps I’ve come across.  I had it setup on Ubuntu in < 5 minutes and it works flawlessly!  Subsonic provides a web interface so you can access and listen to your music from anywhere.  I have it hosted on my own personal server and have tested it seamlessly over both 3G and Wi-Fi. The great thing about this product is there are applications for iPhone, Android and Windows 7 that let you stream music to your phone.  The app I chose for iPhone was iSub Music Streamer.  It cost $5 USD, but is probably the best money I’ve spent in the app store.  Things I really like?

• Transcoding – Even if you don’t have all .MP3s on your server, Subsonic can convert and stream other types on the fly (like AAC, AIF, M4A).  You can also customize audio bitrate based on bandwith usage (Wi-Fi or 3G), but by default I don’t limit.
• Caching – Once you’ve played the song it will be cached.  You can also queue or cache songs ahead of time and force the app into offline mode.
• Playlists – You can create both server-side and client side playlists.  This makes it really easy to share with multiple devices (iPhone(s), iPad, PC, media center, etc.)
• Podcasts – This feature completely eliminates the need for Iphone.  Plug in an RSS Podcast URL and Subsonic will download your podcast .MP3s and keep them updated on demand.

A viable alternative to iTunes?  You bet!  No sync times and music is available from anywhere.  I’m rediscovering my music collection all over again and listening to music I haven’t really bothered with in years.

Jaikoz Audio Tagger (http://www.jthink.net/jaikoz/)

Years ago I used a very good Windows program called MP3Tag to cleanup my music collection.  This program would let you bulk-edit the MP3 ID3 tags (Artist, Album, Track, Year, etc.) and rename files.  This program still works well but I found an even better alternative.  Jaikoz (20GBP-~$33USD) is another amazingly slick app. It does everything that MP3 tag does plus more:

• Integration with online metadata sites like MusicBrainz and Discogs to automatically identify files
• Acoustic fingerprinting using Amplified.  If you have a file with no identifiable information in the filename or metadata Amplified will most likely find it (think Shazam or SoundHound)
• Adds album cover art and lyrics

A few years ago I blogged about an incident where my first iPod Video music db became corrupt and I lost information on about 500+ songs (meta data was non-existant in most of them and files were renamed to something like QD3K33.mp3).  Unbelievably Jaikoz was able to recover about 95+% of the files and even added album cover art and lyrics!

Noteburner (http://www.noteburner.com/)

Since Rhapsody and Amazon started offering .MP3 downloads all of my online music purchases have been through them.  However, I still have (had) hundreds of DRM-protected songs that I purchased through iTunes and Rhapsody.  Back in 2008 I went through some pain to burn the Rhapsody purchases to CD and then rip them again back to .MP3.  This time around I wanted to find a way to make it easier.  I’ve used virtual CDRW software in the past like CDBurnerXP and it worked well.  Noteburner, a worthly alternative ($39.95), offers many of the features of CDBurnerXP but also burns to CD and converts to MP3 in a single-step process!  Simply install, select as your preferred CD-RW drive for burning and burn the playlist.  Noteburner will automatically create the virtual CD, read the CD-TEXT provided by itunes, and create the .MP3 file.  Once you have all your converted files, simply load them into Jaikoz and get the full range of meta tags including album cover art and lyrics.

My total cost for this little project was less than $75 and I couldn’t be happier.  I now have a clean music collection that I can access from anywhere in the world, and don’t have to feel the iTunes pain ever again.  C-ya!!