The Nuclear Bunny Blog » Technology

You Don’t Need Flash for Rich Graphs on a Web Page

chadwick — Sun, 11 Apr 2010 21:35:33 +0000

Adobe’s Flash has a lot of uses, but one of the most impressive to me has been the the creation of interactive graphs on a web page. One just has to visit Google Finance to see a great example of this in action; it’s fast, effective and fits seemlessly within the rest of the page.

Many times, however, Flash isn’t an appropriate technology to use. If you’re an open-source product like Zenoss, Flash presents a licensing issue. If you’re targeting mobile platforms like the iPhone, Flash isn’t available. And, sometimes, you may just not like Flash; it does have it’s own security problems and overhead, for example. What’s a web developer to do? Enter HTML5 to the rescue…

HTML5 is not yet an approved standard, but it’s well on its way and surprisingly well-supported by the browser community already. One of the nice new features provided in HTML5 is the canvas element which allows for two-dimensional drawing functionality. Between this new feature and JavaScript, we should be able to create a rich graph display.

To get started, we’ll first need to create an HTML document that has the structure we’re after and a place for our drawing canvas to reside.



  
    Rich Graph Example using HTML5's Canvas Element
  
  
    Rich Graph Example using HTML5's Canvas Element

Next, we’ll need some JavaScript to do the work of creating the actual graph display. First, we’ll need to get a reference to the canvas DOM element and then ask it for it’s 2D drawing context:

    var graph1 = document.getElementById('graph1');
    var context = graph1.getContext('2d');

Next, we’ll need to define the raw data used to display the graph. We’re going to assume a set of CPU processor time measurements with 5-minute measurement intervals, much like you would see in Zenoss or other systems management application.

    // Raw data, such as what might come back from a server query.
    data = [
      { value: 9.9430, time: new Date(2010, 4, 9, 7, 50, 0, 0) },
      { value: 0.0000, time: new Date(2010, 4, 9, 7, 55, 0, 0) },
      { value: 0.0000, time: new Date(2010, 4, 9, 8, 00, 0, 0) },
      { value: 0.0000, time: new Date(2010, 4, 9, 8, 05, 0, 0) },
      { value: 5.5828, time: new Date(2010, 4, 9, 8, 10, 0, 0) },
      { value: 1.0000, time: new Date(2010, 4, 9, 8, 15, 0, 0) },
      { value: 25.3120, time: new Date(2010, 4, 9, 8, 20, 0, 0) },
      { value: 45.8210, time: new Date(2010, 4, 9, 8, 25, 0, 0) },
      { value: 98.3211, time: new Date(2010, 4, 9, 8, 30, 0, 0) },
      { value: 96.1290, time: new Date(2010, 4, 9, 8, 35, 0, 0) },
      { value: 94.9128, time: new Date(2010, 4, 9, 8, 40, 0, 0) },
      { value: 98.3219, time: new Date(2010, 4, 9, 8, 45, 0, 0) },
      { value: 32.4912, time: new Date(2010, 4, 9, 8, 50, 0, 0) },
    ];
 
    // Calculate the maximums in the provided data.
    var maxY = 0.0;
    for (var i = 0; i < data.length; i++) {
      maxY = Math.max(data[i].value, maxY);
    }
    var dataMaxY = Math.ceil(maxY);
    var dataMaxX = data.length;

Now, we have to calculate where we can start drawing on the canvas and how many pixels equal one coordinate in our user space data. The more elaborate legends we’ll want to use on the graph, the more these calculations will matter as we leave space for drawing text around the actual graph.

    // define a font to use for legends
    var fontHeight = 20;
    var font = "12px/20px arial, sans-serif";
 
    var xStart = 0;
    var yStart = fontHeight * 2; // leave room for 2 lines of text at the bottom
    var xEnd = graph1.width;
    var yEnd = graph1.height;
 
    // Determine how many pixel units equal one user space coordinate.
    var xStep = dataMaxX / (xEnd - xStart);
    var yStep = dataMaxY / (yEnd - yStart);
 
    // Create an array of 2D points to represent the user space
    // coordinates of each data item.
    points = new Array(data.length);
    for (var i = 0; i < data.length; i++) {
      var x = i / xStep + xStart;
      var y = data[i].value / yStep + yStart;
      points[i] = { x: x, y: y };
    }

Now we get to the actual drawing of the graph. This is straight-forward 2D drawing that should be familiar to anyone who has done it with other technology.

    // Save the graphics context before we begin mucking with it.
    context.save();
 
    // Create a transform so that the graph portion of the chart can be
    // drawn using a bottom-left origin instead of the default upper-left.
    context.translate(0, yEnd);
    context.scale(1.0, -1.0);
 
    // Draw our path using the appropriate color.
    context.beginPath();
    context.strokeStyle = 'black';
    context.lineWidth = 5;
    context.moveTo(points[0].x, points[0].y);
    for (var i = 1; i < points.length; i++) {
      context.lineTo(points[i].x, points[i].y);
    }
    context.stroke();
    context.restore();

At this stage, we can render a simple line-graph using JavaScript and an HTML5 canvas element. Now about making it rich and interactive? We’ll need to add some mouse event handling. We’ll do something simple here: as the mouse moves along the x-axis of the graph we’ll find the current data point based solely on its x-position. This technique is more useful to an end-user and saves the calculation of finding how close a point is to a line segment.

Mouse events are still rather browser specific, so the calculations presented here to determine the offset of the mouse inside of the canvas are simplified and will not work in all scenarios.

    graph1.addEventListener('mousemove', mouseWatcher, false);
 
    function mouseWatcher(evt) {
      // Get the mouse position relative to the canvas element. This stuff
      // is still gnarly across browsers. Here we're assuming we need to
      // figure out the offset the canvas has in the client area, so our
      // mouse position is really relative to the canvas, not the client area.
      var x = graph1.offsetLeft + evt.clientX;
      var y = graph1.height + graph1.offsetTop - evt.clientY;
 
      // Get the data point at this X position
      var foundPoint = -1;
      var x1 = points[0].x;
      for (var i = 1; i < points.length; i++) {
        var x2 = points[i].x;
        if (x >= x1 && x <= x2) {
          foundPoint = i-1;
          break;
        }
      }
 
      if (foundPoint >= 0) {
        txt = "" + data[foundPoint].value.toFixed(2) + " @ " + data[foundPoint].time.toDateString();
 
        // draw a new information line in the legend
        context.save();
        context.font = font;
        context.clearRect(0, yEnd - fontHeight, xEnd, fontHeight);
        context.fillText(txt, 0, yEnd, xEnd);
        context.restore();
      }
    }

And that’s it. Over your Sunday morning coffee you can write a simple, yet effective, interactive graph display using HTML and JavaScript alone. Clearly, a tremendous amount of work remains to make the graphs beautiful and robust, but luckily a large number of people are already working on libraries to do this work for us.

Internet Explorer will not yet display canvas elements natively, but luckily this problem is being solved for us.

There are other problems, too. Today, for example, the font measurement abilities in the HTML5 specification are lacking.

If you want to see the example in action click here. View the source in your browser to see the final source code to the example. A screenshot of the example is below.

Share and Enjoy:

An Early iPad Review

admin — Tue, 06 Apr 2010 01:33:11 +0000

I’ve been using the iPad heavily for 2 days now. There is an awful lot of potential in this device, ands there is no doubt that the best is yet to come.

If you are already an iPhone user, the iPad will simultaneously feel familiar but also so incredibly rich and powerful compared to it’s little brother. The extra screen real estate is in itself nice, but more importantly is how the iPhone OS’s approach to user interaction makes use of this extra room.

For example, the Mail app shows each message in full screen glory, but with a fast overlay window to show message and folder navigation. The usability effect is wonderful. Using Safari is now like browsing on a regular computer, except with a multi-touch interface.

I don’t play very many games on the iPhone or iPad, but the Words With Friends game (think Scrabble) is almost worth getting an iPad for just to play it. I suspect the casual gaming crowd I’ll a have a lot to look forward to with their new toy.

Battery life on the iPad has been better than I expected. A little over 48 hour into ownership and I’m down to 10% battery life. I’ve used it a lot, including a lot of reading, so it seems to hold up well there. While it does not compare to the extra long battery life of a Kindle, the device does so much more it seems like a good trade-off.

As far as being an e-reader, I like the iPad better than the Kindle DX (that I normally read from), but not as much as the regular Kindle 2. That device is sized so well, and the battery life is so good, it’s easy to see it remaining the king of its segment for a while. That said, I am a guy, so i like big screens, and here the iPad wins over the DX. The iPad is a touch heavier, but it still feels natural to hold. A minor, but very nice feature in the iPad is the physical orientation lock button, something which the DX has as a software feature that is hard to use.

I plan on using my iPad as a replacement for my laptop for casual computing. It seems like it is going to do that job well. They keyboard is easy enough to use even for this blog entry, and the heavy writers out there may find the keyboard dock option even better than lugging around a laptop.

Share and Enjoy:

My Zenoss Development Environment – Part 3

chadwick — Thu, 22 Oct 2009 22:01:01 +0000

In Part 1 of this series we discussed getting an initial Zenoss environment checked out and running on a Mac OS X or Ubuntu system. In Part 2 we discussed how to configure Eclipse to use the Zenoss source. In this part, we’ll discuss how to handle day-to-day operations such as branch management and working with multiple versions.

Branch-Based Development

At Zenoss we do all development, including bug fixes and small maintenance tasks, in a private development branch within the subversion repository. This allows us to independently work-on changes, check-them into the repository for safe-keeping, and then perform code reviews with team members without having to share files or using pastebin style tools (even though we do both at times).

Create a branch within your user’s sandbox. In this example, I’ve decided to name the sandbox new-widget to identify what I’m working on. If I were fixing a defect, I’d use the defect number from the defect tracking system. Create the branch by copying the trunk folder to the sandbox branch. In Subversion this is a low-overhead operation and doesn’t actually copy files.svn copy http://dev.zenoss.org/svn/trunk http://dev.zenoss.org/svn/sandboxen/cgibbons/new-widget -m " * Copying trunk to sandbox branch."
Switch your working directory to use the new sandbox branch. You can do this either from the command-line or using Eclipse. From the command line, you’d do the following:cd $HOME/zenoss/core svn switch http://dev.zenoss.org/svn/sandboxen/cgibbons/new-widgetFrom within Eclipse, secondary-click on the core project and choose Switch to Another Branch/Tag/Revision… option from the Team menu. On the dialog that appears, enter in the sandbox URL. After switching, your Eclipse will show the new location next to the core project item.

Once your development environment has been switched, you can make changes and commit to the Subversion repository as desired. If you’re unsure if you are in the right branch, you can always use the svn info command to see which directory is being used.

Merging Branches

Once you have completed changes in a branch and have had them reviewed by a peer, it is time to merge them into trunk (or another branch, if using a maintenance release). Merging can be tricky, but a consistent process can make it much easier to handle.

Change your working directory to a checked-out and clean version of the branch you want to merge into. For example, I keep a $HOME/zenoss/clean-trunk directory that I never make changes to, except for merging.
Determine the base working revision of your working branch. There are a variety of ways to do this, but one of the best is to view the revision log graph within the Trac system directly. For example, for the branch discussed above we can browse to http://dev.zenoss.org/trac/log/sandboxen/cgibbons/new-widget/ and see that revision 15513 is the base.
Perform a dry-run on the merge to get a general idea of what the changes into the branch will be. You should see your expected changes, plus any conflicts from changes to the other branch while you have been working in the sandbox branch.svn merge --dry-run --revision 15513:HEAD http://dev.zenoss.org/svn/sandboxen/cgibbons/new-widget .
If the merge results look satisfactory, rerun the command without the dry-run argument.
Look at the final merge results using svn status and svn diff, and once you’re ready, issue an svn commit.

Multiple Branches and Zenoss Configuration

As you switch between branches you will often render your Zenoss configuration useless. Resetting your database after each branch switch is usually a good practice, and being able to quickly recreate any test data you may need makes this process less painful.

After switching a branch, my process is usually the following:

Shutdown zenoss and restart only zeo.zenoss stop zeoctl start
Run the zenwipe script from the inst source directory.$HOME/zenoss/inst/zenwipe.sh --no-prompt
Run zenmigrate to install any database changes available within the current branch.

Depending upon the task at hand, I may install additional ZenPacks and add new devices through the command-line if those are needed. Helper scripts, such as install-windows.sh to install of the Windows ZenPacks and create several local test devices in the instance, are useful tools to have for your typical configurations.

Share and Enjoy:

My Zenoss Development Environment – Part 2

chadwick — Thu, 22 Oct 2009 19:26:36 +0000

In Part 1 of this series we discussed getting an initial Zenoss environment checked out and running on a Mac OS X or Ubuntu system. In this part, we’ll discuss configuring Eclipse to use this environment.

Mac OS X Prerequisites

Install Eclipse Classic 3.5.x Mac Cocoa 32-bit.

Ubuntu Prerequisites

Install the Sun Java JDK. Why? Eclipse is a Java application and requires a full-fledged Java environment to run properly.sudo apt-get -y install sun-java6-jdk
Install Eclipse Classic 3.5.x Linux 32-bit.

Eclipse Configuration

In part one, we created a Zenoss root project directory of $HOME/zenoss – use that directory, or the one you created, for the rest of these steps.
Launch Eclipse and configure it to use the Zenoss root project directory. Why? Eclipse needs a workspace directory to keep track of configuration settings for a group of related projects. By placing the workspace directory inside of the Zenoss root workspace, we can separate the requirements for a Zenoss workspace from other projects you may be using.
Install the PyDev plug-in for Eclipse. Why? PyDev provides Python language support to Eclipse.
1. Go to the Help Menu and choose Install New Software.
2. In the Available Software dialog, choose Add and enter in http://pydev.org/updates/ as the Location and close the dialog. Eclipse will return to the Available Software dialog.
3. Software matching PyDev will appear in the dialog; pick the PyDev option but do not pick PyDev Mylyn Integration. Click Next and install the plug-in.
Install the Subclipse plug-in. Why? Subclipse allows you to work with the Subversion version control system directly from within Eclipse.
1. In the Available Software dialog add the Subclipse plug-in update site: http://subclipse.tigris.org/update_1.6.x
2. In the Available Software dialog, choose the Subclipse, Subversion Client Adapter, Subversion JavaHL Native Library Adapter and the Subversion Revision Graph items.
Go to the Window menu, choose Open Perspective and then SVN Repository Exploring (you may have to choose Other… to see this option).
Choose the New Repository Location button in the SVN Repositories panel. Add the Zenoss SVN site at http://dev.zenoss.org/svn
Open the SVN repository and select the trunk folder. Secondary-click the folder and choose the Checkout… option. Be sure to change the Depth option to be Only this item so that we don’t check out any of the sub-folders of trunk just yet (many of the folders within trunk are not needed for development, but we want to keep the directory structure). In the next dialog you will be asked to choose a Project Wizard. Open the Pydev tree item and select the Pydev Project option.
Create the project in the Pydev Project dialog:
1. Use core as the project name and use the default location. This should create a core project at $HOME/zenoss/core.
2. Make sure the Python project type is selected.
3. Select 2.4 as the Python Grammar version.
4. Uncheck the Create default ‘src’ folder... option.
5. Click the Click here to configure an interpreter not listed… option in order to add the python interpreter built by the Zenoss installation scripts.
  1. In the Preferences Dialog, choose the Interpreter – Python item underneath Pydev and select the New… button to add a new Python interpreter.
  2. Browse to the $ZENHOME/bin directory and choose the python2.4 executable from that directory.
  3. Name the interpreter python-2.4, zenoss-python or some other variant.
6. Update the core folder from the command-line SVN client so you can selectively pull the sub-folders of the core project and not all of them:cd $HOME/zenoss/core svn update Products
7. Move the Products directory the installation checked out and create a symbolic link to the one updated above. Why? This allows the Products source tree to be worked on from Eclipse and then also used by the Zenoss run-time.cd $ZENHOME mv Products Products.old ln -s $HOME/zenoss/core/Products Products
8. Return to Eclipse and choose the Refresh option from the File menu so that Eclipse notices the updated directory and builds necessary dependencies.
9. Secondary-click on the core project folder in Eclipse and choose Properties. Choose the PyDev – PYTHONPATH item and add source folders so PyDev can reference the project from within itself.
  1. In the Source Folders tab choose the Add source folder button and pick the root core folder from the provided list.
  2. In the External Libraries tab choose the Add source folder button and choose the $ZENHOME/lib/python directory.
At this point, your Eclipse project should allow you to navigate between dependencies within the Zenoss project. You can also simultaneously switch between using the Team feature within Eclipse to update and manage Subversion or do so using the command-line svn client.

Next…

In Part 3 of this series, we’ll discuss how to manage day-to-day activities such as creating sandbox branches for changes and dealing with multiple versions are done from within the same environment.

Share and Enjoy:

My Zenoss Development Environment – Part 1

chadwick — Thu, 22 Oct 2009 17:05:46 +0000

Over the past 18 months the developers at Zenoss have used a variety of development environments and methods to productively work with Zenoss, but there are a lot of best practices that have emerged out of this diversity.

I develop Zenoss primarily on Mac OS X, with some work done on Ubuntu when necessary. I normally use Eclipse as my development editor, although I’ll often just use vim when doing quick changes or bug fixes. In either case, careful setup of the Zenoss environment is key to being able to productively work with both the new development version and with the shipping versions that require maintenance.

The environment you get by default when you check out the source version of Zenoss from the source repository, or from a source tarball, is not necessarily setup in the best way to develop productively using tools like Eclipse.

The rest of this post will document how both my Mac OS X and Ubuntu environments are initially configured so that a working source Zenoss installation is realized.

Mac OS X Prerequisites

These prerequisite instructions assume Mac OS X 10.5 Leopard; 10.6 Snow Leopard will not be able to compile Zenoss’s third-party dependencies, so an additional work-around is required for that platform until Zenoss moves to Python 2.6.

Install Xcode. Why? Installs the GNU C/C++ compiler and other command-line development tools needed to build dependencies used by Zenoss.
Install Universal Subversion 1.6.x from CollabNet Community.Why? Leopard only comes with Subversion 1.4.x. This version is not compatible with the Subclipse plug-in for Eclipse that will be used later. In order to be able to use both the command-line and Eclipse Subversion versions simultaneously on the same checked our source, the release of subversion should match. This installation will place the Subversion binaries in /opt/subversion and should automatically add it to your PATH.
Install MySQL Community Edition 5.1 32-bit. Why? Zenoss needs MySQL for storage of event data.

Ubuntu Prerequisites

These prerequisite instructions assume Ubuntu 9.04 32-bit Desktop Edition. Installing the server edition or one with different options may require additional prerequisites to be installed.

Install Subversion. Why? Working with the Zenoss product in source form requires Subversion to access the source repositories (it is also possible to build directly from a source tarball, but this is not discussed here).
sudo apt-get -y install subversion
Install MySQL. Why? Zenoss needs MySQL for storage of event data.
sudo apt-get -y install mysql-client mysql-server libmysqlclient15-dev
Install additional development environment tools. Why? Zenoss third-party dependencies require several binaries to be built from source.
sudo apt-get -y install patch make vim gcc g++ autoconf
Install SNMP support. Why? Zenoss requires SNMP libraries for monitoring, and having a local SNMP agent is useful for testing.sudo apt-get -y install libsnmp-base snmp snmpd
Install Liberation TrueType fonts. Why? Graphs generated by RRDtool will not contain the correct glyphs without this font package.sudo apt-get -y install ttf-liberation

Environment Configuration

Configuring Eclipse will require determining where you want to work with your Zenoss installation, and installing Eclipse plug-ins to provide the features required for Python and Subversion support.

Create your Zenoss root directory:mkdir $HOME/zenoss
Create and run a setup.sh script that will configure needed environment variables for zenoss. This script can be started from your log in profile if desired.cd $HOME/zenoss cat > zenoss-config.sh < ZENHOME=$HOME/zenoss/zenhome PYTHONPATH=$ZENHOME/lib/python PATH=\$ZENHOME/bin:\$PATH export ZENHOME PYTHONPATH PATH EOF chmod +x zenoss-config.sh . zenoss-config.sh mkdir $ZENHOME
Checkout the Zenoss source installation tree. Why? This tree is used to bootstrap the installation from the source repository and create a running Zenoss installation. We’ll need this before we modify it to fit the needs of our development environment.svn co http://dev.zenoss.org/svn/trunk/inst inst
Run the installation script to checkout, compile, and configure a zenoss environment. If you need to customize your MySQL configuration at all do not use the --no-prompt argument.cd inst ./install.sh --no-prompt
Modify the zensocket file to be setuid root. Why? Some of the Zenoss daemons use a privileged port and making the file owned by root and accessible by the Zenoss user allows the daemons to be run as a non-priviledged user but still use the privileged port.sudo chown root:`id -g` $ZENHOME/bin/zensocket sudo chmod 04750 $ZENHOME/bin/zensocket

At this point, you should have running zeo and zope processes and be able to log on to the local Zenoss instance. Your Zenoss root directory should look similar to the following:

Next…

In Part 2 of this series, we’ll download and configure the Eclipse IDE.

Share and Enjoy:

Why is my car’s satellite navigation system so stupid?

chadwick — Fri, 18 Sep 2009 23:57:27 +0000

I have two different late model (a 2006 and a 2007) GM vehicles with satellite navigation systems. Both are manufactured for GM by Denso, although they clearly have different implementations and features. The one thing they both share, however, is blatant stupidity when calculating routes.

I travel quite a bit between Houston and Austin and there are really only three reasonable ways to go: US-290; I-10 & TX-71; or I-10 & TX-183. Over the years my preference has moved from US-290 to I-10 & TX-71 as traffic along US-290 has increased on the eastern fridges of the Austin area, but the distance and time between the two is very similar and really it depends upon where in Austin you might be headed.

The GPS systems in my cars have three route options when you pick a destination: fastest, shortest and other. In both cars, the route displayed is none of the above three, but instead a long, out-of-the-way route of I-10 to Seguin before heading north on TX-123 to San Marcos, and then heading into Austin on I-35. This option is a whopping 222 miles with an estimated travel time of 3 hours and 39 minutes.

Now, the fastest route is usually not the shortest. Route calculations are supposed to take into account the actual speeds of the road segments involved, and since interstate highways are almost always faster than anything else, there is a natural preference to these roads. In this case, however, the calculation is way off. Taking I-10 to US-71 (via US-59 & TX-8 inside of Houston for those familiar with the area) is only 166 miles and estimated to take 3 hours 29 minutes according to Google. Likewise, taking US-290 is only 168 miles and estimated to take 3 hours 22 minutes.

Of course these time estimates are usually worst case scenario. Driving a few miles per hour over the speed limit I often make my trip in 2 hours and 30 minutes; worst case has been 3 hours and 10 minutes when driving 55 as an experiment (a painful one at that).

What about the shortest route option in the GPS system? That does actually route you onto I-10 & US-71 in this example, but the shortest route calculations are always incredibly stupid, too. They will often take you onto side streets for half a mile or less just to maintain the shortest possible distance. Once, when driving through Memphis, TN, the GM GPS took us on and off the interstate highway three times when driving through town, often for just a couple of blocks, just to maintain the shortest distance. Granted this is a clear example of a GPS system not being there to replace your own intelligence, but if you don’t know the town…

In the early days of consumer-level GPS systems, one of the common problems was having accurate speed data for different road segments. In western states especially, secondary highways often have the same speed limits as interstate highways. In Texas, the past 20 years has seen many of these highways improved so they route around the smaller towns, rather than going through them and stopping at every light. Consequently it is often better to take these roads than the interstates whenever possible. If the GM GPS systems do not have accurate speed data then it can account for some of this behavior, but not all.

On my normal route, once you finally hit TX-71 and the GPS decides you mean it, suddenly the estimated arrival time drops dramatically along with the distance. Is it computing this arrival time based upon your actual speed so far, or based upon the speed data of the road?

Over the years I’ve gone from absolutely wanting a satnav system in the car to wishing mine didn’t. I get much better results using a smart phone with Google Maps to get a general idea of the route to take and then consulting with it now and then if things get tricky. But for the most part, they seem poorly done enough that they just get in the way rather than help. Will the newer generations out now that provide real-time traffic data and have hard-disk based data improve their logic and performance enough that these problems are solved?

One final note for embedded systems developers: you don’t get to break the interactive response time rule of 250ms just because you are writing code for an embedded system.

Share and Enjoy:

IcyBee needs a new maintainer

chadwick — Thu, 03 Sep 2009 23:16:05 +0000

The IcyBee project is a client for the ICB chat network with a graphical user interface and written in the Java language for cross-platform portability. The current version of the software has several years of stability behind it and few user requests, but there is always more work to do. The project is currently hosted on SourceForge and all of the source is already available.

I’m looking for a maintainer that will take the reins of the project from me and give the project some much needed love as time and platforms march on. If interested, drop a comment on this post and we can discuss the possibility.

Share and Enjoy:

Review: Garmin Forerunner 310XT

chadwick — Mon, 24 Aug 2009 04:33:27 +0000

I recently purchased a Garmin Forerunner 310XT training device for use while running, cycling, and hopefully swimming. The Forerunner 310XT is a new device from Garmin, and their first multi-sport device that is waterproof and can be used for swimming, and thus triathlons.

For the past several years I have been using a Polar S725X multi-sport training device for both running and cycling. The rest of this review will compare and contrast to the Polar device since that is what I am most familiar. I have not used other GPS-based training devices before, so comparisons with those are left as an exercise for the readers.

The 310XT uses GPS to calculate your location and speed. You can then upload your data via your computer to Garmin’s Connect website, Garmin’s Training Center software, or other third-party options. After uploading you can view a map of your route, categorize and describe your activity. With the Connect website, you can easily share your activity via variety of methods, and even export the route into Google Earth.

Like most of Garmin’s training devices, you can pair the 310XT with a variety of other devices that communicate using the ANT+ Sport protocol. The 310XT will receive and record data from heart-rate monitors, bicycle speed & cadence sensors, foot-pods, and even power meters such as the Saris PowerTap. The collected data is then joined with your route data and transmitted along with it.

The bicycle sensor option from Garmin is a combination speed & cadence sensor that mounts on the rear chainstay. This design allows one sensor unit to have two separate magnets for both the crank and the rear wheel. Compared to the Polar solution, this is much cleaner and easier to mount than two separate sensor units. The Polar cadence sensor, especially, is difficult to mount on some of the modern carbon downtubes, so the Garmin solution is a welcome change.

The speed sensor augments the GPS data so that accurate speed is recorded even when GPS signal is not available or accurate. Garmin also sells an optional foot pod sensor that accomplishes the same when running without GPS signal, such as inside on a treadmill. I haven’t used this sensor yet as where I have run has had great GPS reception thus far.

I used a foot pod sensor with my Polar to keep track of my speed and distance while running. The downside of this type of solution is the relative inaccuracy of the data. I’d often see 10 to 20% margin of error, even after calibrating the foot pod.

My concern with a GPS-based training device would be the accuracy of the signal, especially when running under under a lot of foliage. So far, the 310XT has proven itself more than capable in this regard, and much better than other GPS devices I have used in the past. Viewing the recorded route data I’ve found very little error in position so far, and only a little bit with elevation, even when running underneath trees and bridges.

Like all GPS devices, the 310XT must determine its position when it is powered on. If you start up the 310XT inside, or where there is poor GPS signal, it can take a very long time to determine initial position, if it all. This can be an annoyance when you’re ready to start your training and you don’t have a solid 3-dimensional fix yet. The 310XT lets you begin your timer and start your activity before it has GPS signal, but it can sometimes take surprisingly long to get that initial fix. Another disadvantage of not having a fix is you won’t have accurate local time until then, either.

The Garmin 310XT has a rechargeable battery, but battery life is only approximately 20 hours of usage. My Polar S725X, by comparison, has a watch-style battery that has lasted over 5 years. In practice, a rechargeable battery solution works great, but may present a problem on multi-day activities where there is no opportunity to recharge.

Transmitting the data from the training device to your computer is done via a USB dongle that uses the ANT protocol. Garmin provides drivers and software for both PCs running Windows and Macs running OS X. The Polar solution uses an infrared based receiver that is much more difficult to work with as it requires line of sight between the training device and the infrared receiver, and Polar does not provide a software option for Macs.

For most users, Garmin’s software solutions are stellar compared to Polar’s. The big win here is Garmin’s Connect website which allows you to easily view your data online, share it with friends, and upload your data from a variety of different computers. Sharing your data is trivial, and allows your friends to view your routes, as well as being able to search for routes from others near you. The Connect website represents a modern solution for the social Internet, a great solution for most users.

Where the Polar software shines is for advanced heart-rate based training, especially with coaching assistance. Polar’s software is designed to easily share your data with a coach and receive training programs with them. Additionally, both the software and the Polar device have much more advanced features for heart-rate based training. For example, with the Polar I can run several tests to determine if I am over-training, or even what an estimate of my current VO2max. The Garmin solution only has different heart rate zones, more than adequate for most users, but you do get the impression the Polar has more science behind it.

The 310XT supports multiple bike settings, each with its own odometer. I find this feature in particular compelling as I like to keep track of my mileage for each bike separately, and as far as I could tell the Polar S725X always combined bike mileage for all bikes it had configured, rather than a separate odometer for each one. With the GPS based tracking, you don’t even necessarily need a speed/cadence sensor and you can still keep track of your bike’s mileage. This is especially compelling for mountain biking, where the rough trails often render a traditional bike computer useless.

So far, the Garmin Forerunner 310XT has been a fantastic training tool and I haven’t missed using the Polar S725X yet.

Share and Enjoy:

Connecting to Apple Push Notification Services using Python & Twisted

chadwick — Mon, 11 May 2009 15:34:01 +0000

One of the exciting features of the upcoming iPhone 3.0 operating system is the ability for a device to receive a notification message from your own application that is relayed by Apple’s network cloud. This feature allows the iPhone to channel all out-of-band communication into a narrow channel that is low impact on the device from a power, security and usability point-of-view.

As an application developer, you are responsible for two pieces to make this new notification service work: the actual application that runs on the iPhone OS, and a provider service that both communicates with the device and directly to Apple’s cloud.

In a typical flow, the application on an iPhone device issues an API call to request notifications for the identifier that the developer has assigned to the application. In response to that API call, Apple’s servers provide the device with a binary token value that uniquely identifies the device & installation combination (for security reasons, the device token is reset if the device is reset, so it is not a one-to-one mapping to the actual hardware). Next, the application must connect to the developer’s provider servers and provide it with the device token it has received from apple. The provider can now use the device token when communicating back to the Apple Push Notification Service (APNS) cloud.

A provider implementation has very little work to do to inform APNS of a device update. Most of the effort in a provider will be in the actual framework of the application itself, and managing what information should be sent to a device. A common implementation will be for a provider to both communicate with the APNS server cloud and also to the application’s own network services and effectively become a protocol translator. Such a heavily network based application like that is a perfect match for the Python language and the Twisted framework.

A provider to APNS link is very simple: a secure-socket connection (SSL) is made to a APNS server and then simple messages are sent by the provider whenever a notification needs to be sent to the device. The APNS server does not respond or acknowledge the message. Every so often (Apple recommends once an hour), the provider server should connect to a web server that will dump a list of device tokens that are no longer valid (as in the device has uninstalled the application). This is the provider’s only feedback mechanism outside of communicating directly with a device.

The first step is to setup an SSL connection to the APNS servers. By following the directions on Apple’s developer portal, you can create a certificate and private key that are assigned to your application identifier. This certificate & private key must then be used when connecting to the APNS servers as an authentication mechanism.

One caveat - the Mac OS X Keychain Access application does not directly export certificates and private keys in Private Enhanced Mail (.pem) format, which is what the OpenSSL implementation we use with Twisted will want, but luckily there’s an easy mechanism to convert if you export the files as Personal Information Exchange (.p12) format. The following two commands can be used to convert the .p12 files into .pem files using the built-in openssl command on Mac OS X or most Linux distributions:

openssl pkcs12 -in cred.p12 -out certkey.pem -nodes -clcerts
openssl pkcs12 -in pkey.p12 -out pkey.pem -nodes -clcerts

Now that we have our SSL files in the proper format, we can build our ClientContextFactory object that will be used by Twisted to initiate a connection to the APNS servers:

class APNSClientContextFactory(ClientContextFactory):
    def __init__(self):
        self.ctx = SSL.Context(SSL.SSLv3_METHOD)
        self.ctx.use_certificate_file(APNS_SSL_CERTIFICATE_FILE)
        self.ctx.use_privatekey_file(APNS_SSL_PRIVATE_KEY_FILE)
 
def getContext(self):
    return self.ctx

We’ll also need a ClientFactory object that will be used to build the Protocol object whenever a connection is established to a server:

class APNSClientFactory(ClientFactory):
    def buildProtocol(self, addr):
        print "Connected to APNS Server %s:%u" % (addr.host, addr.port)
        return APNSProtocol()
 
    def clientConnectionLost(self, connector, reason):
        print "Lost connection. Reason: %s" % reason
 
    def clientConnectionFailed(self, connector, reason):
        print "Connection failed. Reason: %s" % reason

Next, we’ll need the actual Protocol object that will format messages and queue them to the server. For APNS, we don’t receive any responses so that half of the protocol goes unused.

class APNSProtocol(Protocol):
    def sendMessage(self, deviceToken, payload):
        # notification messages are binary messages in network order
        # using the following format:
        # <1 byte command> <2 bytes length> <2 bytes length>
 
        fmt = "!cH32sH%ds" % len(payload)
        command = '\x00'
        msg = struct.pack(fmt, command, 32, deviceToken,
                          len(payload), payload)
        self.transport.write(msg)

And finally, we’ll need the main code to kick everything off for the test:

if __name__ == '__main__':
    reactor.connectSSL(APNS_SERVER_HOSTNAME,
                       APNS_SERVER_PORT,
                       APNSClientFactory(),
                       APNSClientContextFactory())
    reactor.run()

From here, the Python and Twisted combination can be easily extended to handle multiple protocols and convert between them as needed. For example, one of the commonly expected use cases of the new push feature will be instant messaging (IM) clients that will need to provide a proxy between the device and the IM servers and the APNS servers in order to notify a device of outstanding messages.

The full Python script containing the above excerpts can be downloaded here:

test-apns-blog

Share and Enjoy:

iPod installation in the car

chadwick — Mon, 04 May 2009 04:16:33 +0000

Due to recent negative events with XM Radio’s customer service, I no longer have an XM subscription in any of my vehicles. In the truck there is an auxiliary input jack, so feeding music from an iPod is a no-brainer. But in the Corvette, there was no such option. GM never really provided a great solution for it, but luckily the aftermarket came to the rescue.

One of the better options is a device called the Lockpick that intelligently interfaces with the various radio interfaces in GM vehicles. The Corvette Lockpick they provide interfaces directly with the navigation radio in all 6th generation Corvettes so I ordered it to try it out.

Installation turned out to be incredibly simple. The unit ties into the wiring harness that feeds the XM Radio brain. In the convertible model, the brain is hidden behind the waterfall, located between the seats. Removing the waterfall is straight-forward, and then you are left with a simple wire routing problem.

In the end, I decided to locate the Lockpick unit itself on the carpeted area behind the waterfall. I used sticky-tape velcro to keep the unit attached to the carpet, and then ran the wiring harness to the XM Radio unit in order to attach the Y-connector that feeds into the Lockpick itself. The wiring harness that connects to the iPod also has to be routed, and I decided in the end to locate the iPod in the glove box rather than the center console. Access to the center console would require some cutting for a clean installtion look, and plus it tends to get rather hot inside so I was worried about shortening the life of the iPod a bit too much to locate it there.

Luckily the glove box had a space for a switch that wasn’t installed with my option packages, so it made a perfect place to feed the wiring harness. From there, I routed the wiring harness into the dash and then underneath the center console and feed it directly to the waterfall area. The final result is a perfectly clean and hidden installation with no permanent modifications needed to the car.

The Lockpick unit itself works great, although the control system is a quirky. The lower right-hand button in the XM Radio menu activates the iPod. Once activated, the Category up and down buttons control your playlist selection, and then seek forward and back buttons control the current song playing within the playlist. The info button displays the song information as you would expect. It’s quirky, but works extremely well.

Share and Enjoy: