Or you could use an IR Detector placed inside of a short length of opaque tube.  When the bot does not detect the IR strobe, it rotates until it does, then drives forward until the IR strobe again is not detected.  You can enrich the scheme then by placing two more sensors to the left and right of the "center" sensor.  This will tell you which direction the strobe was traveling when it left the center sensor's field of view, and therefore you know which direction to turn to reacquire it.

Place an IR LED beacon on your cat's collar and localize on that?

Welcome!  

You should connect it like a switch using a pull down resistor perhaps.

That's odd... the getQuadDir() function will return one of 4 values.  Either 0 (the wheel didn't move), 1 (the wheel moved clockwise), -1 (the wheel moved counterclockwise) or 999 (a pulse was missed).

The loop() function should only print something to the terminal if something has changed (i.e. the wheel has been turned or a pulse was missed).

Now you're going to make me break out an old mouse, tear out the wheel and try it out! ;-)

How about this one:

Code:

/*
Quadrature Example
*/
int quadAPin = 1;
int quadBPin = 2;

int lastQuadValue;

int CLOCKWISE = 1;
int CCLOCKWISE = -1;
int MISSEDPULSE = 999;

void setup()
{
  lastQuadValue = readQuadValue();
  Serial.begin(9600);
}

void loop()
{
  int newQuadValue = readQuadValue();
  int quadDir = getQuadDir(lastQuadValue, newQuadValue);
  
  if (quadDir == CLOCKWISE) Serial.print("Clockwise");
  if (quadDir == CCLOCKWISE) Serial.print("Counter Clockwise");
  if (quadDir == MISSEDPULSE) Serial.print("Missed Pulse Detected");
  
  lastQuadValue = newQuadValue;
}

int readQuadValue()
{
  int val = digitalRead(quadAPin);
  val = val * 2 + digitalRead(quadBPin);
  return val;
}

int getQuadDir(int prevVal, int newVal)
{

  //because the step order is 0, 1, 3, 2 lets do some switching around

  if (newVal == 3)
    {
      newVal = 2;
    }
  else
  {
    if (newVal == 2) newVal=3;
  }

  if (prevVal == 3)
    {
      prevVal = 2;
    }
  else
  {
    if (prevVal == 2) prevVal=3;
  }
  
  int quadDir = prevVal - newVal;
  
  //see if we missed a pulse (i.e. quadDir is 2 or -2)
  if (abs(quadDir) == 2) quadDir = MISSEDPULSE;
  
  return quadDir;
}

I haven't actually tried it, but it should work.

The answer is "Quadrature".  Here have a look at this:  http://en.wikipedia.org/wiki/Rotary_encoder#Incremental_rotary_encoder

The three contacts serve as two bits, with one contact being common.  With two bits, you have 4 possibilities... 00, 01, 10, 11.  The order they appear in tells you the direction.

I guess the MOC3010's are sort of the opposite of what you were proposing huh?  

I always keep a few MOC3010's on hand for just such an eventuality.

Or you could sample the switch values and then use that value to set the wiper position of a digital potentiometer chip that served as the volume control of your audio amplifier.

http://www.onsemi.com/pub_link/Collateral/P2N2222A-D.PDF
http://www.onsemi.com/pub_link/Collateral/2N3903-D.PDF

Note 1,2,3 vs 3,2,1...

Holy cow they are!  I never noticed that before.  I'm just in the habit of just grabbing the data-sheet to look at before I hook anything up.  I never noticed that they are exactly backwards of one another.

Sure, use a digital potentiometer.

Ok, I finally got that to compile.  Unfortunately, that did not solve the issue.

There are definitely issues with the standard LiquidCrystal library when used in conjunction with the Wire library.  Reading this thread leads me to believe the conflict does not exist between the 4BitLCD library & the Wire library.  I haven't yet tried swapping it out however, but it is my intention to do so.