(This is Part Two in an ongoing series which starts at Part One).

To answer all the questions raised in part one, there is only one thing we really need to know:

How far does our hamster run in a particular period of time?

The “how far” part should be quite easy, because the little critter is running in a fixed wheel – no need for a micro-GPS tracking bug here.  Some mechanism for counting how many times the wheel turns should be sufficient.

So, how can we measure the rotations of a wheel like this?  Well there are several ways, but the one I’ve gone for to start with, due both to the simplicity and the fact that I have the parts on-hand, is the reed switch.

The Humble Reed Switch

A reed switch is a simple device.  It’s essentially just two bits of metal in a sealed glass tube, and the ends overlap slightly but don’t quite touch – the switch is open.  If you wave a magnet around near them though, they magnetise and stick together.  CLICK – switch closed.

What this means is that we don’t need to have any direct mechanical contact between the stationary Rodentometer and the spinning wheel.  We can attach the reed switch to the edge of the back part of the wheel (the bit that’s not spinning) and glue a little magnet to the spinning part of the wheel.  Every time the wheel turns, the magnet will pass near the switch and momentarily close it.  Those little “ticks” of the switch is what we will count – each tick is another 54cm travelled.

The Similarly Humble Push Button

A little switch on the project will allow for easy resetting of the statistics, without the vulgar resort of just pulling the plug. I used ones very similar to those pictured above, but really any sort of simple push-to-make switch will do.

The Brains

As already mentioned in Part One, the brains of the operation will be an Arduino Uno, featuring the ATmega328 microprocessor. This will handle all the input sensing, the distance and timing calculations and finally some sort of output.

The Output

It’s all well and good for the Arduino to know how many revolutions of the wheel there have been, or that the hamster has run for 93km since the weekend, but how are we going to find out?  For that, I’ve decided on several options, and we’ll be seeing all three.

Serial Data

As long as the Arduino is connected to a computer using the USB, it’s really easy to talk to it using the Serial port.  In the code, we just make sure we configure the board to “talk serial”:

void setup() {
  Serial.begin(115200);
}

And then whenever we want to send any messages to the computer we can just do something like:

Serial.print("The current revolution counter is: ");
Serial.println(currentCount);

And then we’ll see that appear in our Arduino IDE as “The current revolution counter is: 123″.

This is basically the main debugging technique for Arduino code – you can sprinkle the Serial.print commands throughout the code and you can see what it’s up to in the IDE.

LCD Display

The more fancy feedback will come from the SparkFun Graphical LCD, which is a nice little 128×64 pixel display, which when coupled with the “Serial Backpack” means you only need two Arduino pins to send it commands.  You can draw all sorts of pretty shapes…

(Part One is not going to have anything exciting and technical in it.  If you’re a geek, and let’s be honest, why would you be here if not, skip to Part Two).

So I live in a house with a Hamster.  Syrian hamsters are pretty great, as pets go: they are fairly tidy*, fairly quiet*, don’t need taking for walks* and don’t poo on the carpets*. The thing about them is, though, that they are active.  During the day they are just fat little lazy potato-shaped furballs, but come evening, like gremlins, the start scurrying, chewing and running about like hopped-up little crazies. The question is – how far does our hamster run?  Is she an athlete, or a lazy good-for-nothing? Read on to see how I plan to find out…

(*most of the time)

The Question

Now, about the running.  They love it.  Really. Ours has a little wheel (well two actually), and once she’s in it, she runs and runs and runs.  I’ve seen it written (on the internet, so it must be true) that in one night they can run up to 9km.  Rats might run 43km in 24 hours.

The questions I really have are:

• How far does our hamster run in a night?
• For how long does she run for every night?
• How fast does she run?
• What is her maximum speed?

The Solution

The answer to my intrigue lies in the formidable Arduino. To directly quote their website:

Arduino is an open-source electronics prototyping platform based on flexible, easy-to-use hardware and software. It’s intended for artists, designers, hobbyists, and anyone interested in creating interactive objects or environments.

Basically, you hook up any switches, lights, sensors or other electronics as required to the various input and output pins on the Arduino, and then program it using a simple IDE.  Upload your code to the board using a USB cable, and off you go!

The key thing to know about the Uno is that it has a bunch of pins that you can attach things to, either for input (buttons, switches, sensors, etc) or output (some LEDs perhaps).  Programming is done in C++, in a simple little editor which uploads using a USB cable.  The Arduino IDE has a bunch of nice touches that means you can do simple things like “digitalRead(PIN)” to get a reading, instead of weird esoteric operations with registers.

The Basics

So the basics of talking to the SerialGLCD backpack are quite simple.  You just hook it up to the serial transmit pin of the Arduino (pin 2 on an Uno), and then just sent bytes to it.   The general form of the commands is to send the byte 0x7C, which means “here starts a command”, and then the command.

Here’s a simple example that draws a little box in the middle of the screen:

Serial.write(0x7C); // command
Serial.write(0x0F); // box
Serial.write(59); // X1
Serial.write(27); // Y1
Serial.write(69); // X2
Serial.write(37); // Y2
Serial.write(0x01); // Draw

The Problem

Seems simple enough.  But… and there’s always a but, the firmware is broken.  So for starters that last parameter (wether to set the rectangle pixels to foreground or background) is totally ignored.  But of course, as any non-command text is printed to the display, it’s not really ignored, it’s shown on-screen as garbage.

Another problem, is that if you run a loop or just generally are sending more than one box to the screen, it corrupts.  You’ll find extra lines, skipped commands, garbage on the screen, and so on.

The Solution

The only solution is to accept that the SparkFun firmware is broken, and write your own.  Okay, maybe not write your own, that’s tricky stuff.  Luckily, a kind individual going by the name of SummoningDark has done this for us, so all we need to do is download his firmware from his SourceForge and burn it onto the backpack using an ISP.

Links

• The Graphic LCD 128×64 STN LED Backlight
• The SparkFun Graphic LCD Serial Backpack
• SummoningDark’s project page on SourceForge
• A great post on the Arduino forums with step-by-step details on building the ISP

Basic Interaction

To start off, and to ensure I’d hooked things up correctly, I use the hardware TX pin 1 on the Arduino.  This means I don’t have to worry about SoftSerial or NewSoftSerial or anything like that.

Here’s a quick sketch that resets the screen, then runs the built-in demo.  It’s probably best to temporarily disconnect the TX lead to the GLCD, otherwise all sorts of garbage will be printed out as the screen ‘sees’ the data going to the PC…

// Clear the screen and start the demo
void setup()
{
  Serial.begin(115200);
  Serial.print(0x7C, BYTE); // Command
  Serial.print(0x00, BYTE); // Clear
  Serial.print(0x7C, BYTE); // Command
  Serial.print(0x04, BYTE); // Demo
}
 
void loop()
{
}

Resetting the Baud

The GLCD backpack communicates by default at the maximum speed of 115,200, but that can be changed using a command.  Whenver I’ve set it slower for testing (I was having trouble using NewSoftSerial at max speed), the easiest way to set it back to max is simply to bash the hardware serial port when the screen boots up.

To make this simple, I created a bare sketch that just opens the serial port and whacks out bits at 115,200.  To use this:

1. Disconnect the GLCD’s +V pin
2. Upload the sketch
3. The Arduino is now cheerily bashing out the letter “a” at it’s max rate
4. Connect the GLCD’s +V pin again
5. The GLCD will now power up, and see 115,200 bits coming at it, and switch itself to that speed

Here’s the sketch:

// Just send characters to the serial port
void setup()
{
  Serial.begin(115200);
}
 
void loop()
{
  Serial.write("a");
}