I just finished installing some hardware for SparkFun's robot tracking system. It's sort of a mixed reality system combining home made robots and hacked together control systems, IR tracking and sweet high res projections from above.

It uses a modded PS3 eye, an ultra-short throw projector mounted above the ceiling, Community Core Vision and Processing running MSAFluid.

The robots can consist of pretty much anything, all that the robots need to be tracked is a simple IR LED pointing upward towards the modded PS3 webcam which now only sees infrared. In this case Tim has attached a small throwy style cell battery, resistor, switch and IR LED together and literally just taped it to his robot.

Tim's sumo robot recently competed and placed at Robothon in Seattle, but now is controlled via a hacked Wiichuck connected to an Arduino and xbee for wireless control.

The InfraRed tracking is done by the PS3 eye with the IR blocking filter removed and an IR filter that ONLY allows infrared light. The result is an all black image with only the IR LED showing up in the webcam. The webcam is directly above projected image hidden in the ceiling.

Community Core Vision is a great piece of free software with a calibration system which has mainly been used for multi-touch screen, but it can also be used for other types of tracking. CCV can output the tracked points via Open Sound Control to Processing...just like TouchOSC in my last project. Or it can output to Flash, which is also really cool, but I don't know much Flash.

Processing can read the OSC signals and interpret them in any number of ways. My favorite easy to tweak demo is Memo's MegaSuperAwesomeFluid TUIO particle system. I just barely modded Memo's code to fit the size of the projection and the speed of the particles emitted from the front of the robot.

That's about it for now, there is definitely more to come. Also if anyone wants to come check out this project or just hack some electronics with us...SparkFun is having a free electronics hacking meetup tomorrow, Dec 5th from 9:30am-2pm in Boulder, CO. Hope to see you there!

Using the super awesome TouchOSC app for the iPhone connected to Processing for converting Open Sound Control signals into serial commands send out via USB to an Xbee...I am able to drive a small tank.

The tank is entirely made from SparkFun parts:
Arduino
Ardumoto
Dual Motor GearBox
Stackable Arduino Headers
Super Awesome Tank Treads
LiPoly Battery Charger
Batteries
Small Solar Panel
XBees
XBee USB board
XBee Explorer board
Also used a number of misc jumper wires, rubber bands, a block of wood and a few small pieces of aluminum (from the back of a PC).

Of course you will need an iPhone to get everything running exactly as I have setup, but you don't need to use an iPhone to control your tank, you could use a midi controller, a multi-touch screen, a random hardware controller, or really anything that can send serial, OSC or anything into Processing.

Here is the Source Code:
Source code for Arduino is from a Mechomaniac.com:

//-----------Start Arduino code ---------------

// Test program for SparkFun Ardumoto board
// Copyright (c) 2009 mechomaniac.com
 
// To use, connect the Arduino to a computer and send commands using a serial terminal.
// eg AR40#   motor A forwards with a speed of 40
 
#define PwmPinMotorA 10
#define PwmPinMotorB 11
#define DirectionPinMotorA 12
#define DirectionPinMotorB 13
#define SerialSpeed 9600
#define BufferLength 16
#define LineEnd '#'
 
char inputBuffer[BufferLength];
 
void setup()
{
  // motor pins must be outputs
  pinMode(PwmPinMotorA, OUTPUT);
  pinMode(PwmPinMotorB, OUTPUT);
  pinMode(DirectionPinMotorA, OUTPUT);
  pinMode(DirectionPinMotorB, OUTPUT);
 
  Serial.begin(SerialSpeed);
}
 
// process a command string
void HandleCommand(char* input, int length)
{
  Serial.println(input);
  if (length < 2) { // not a valid command
    return;
  }
  int value = 0;
  // calculate number following command
  if (length > 2) {
    value = atoi(&input[2]);
  }
  int* command = (int*)input;
  // check commands
  // note that the two bytes are swapped, ie 'RA' means command AR
  switch(*command) {
    case 'FA':
      // motor A forwards
      analogWrite(PwmPinMotorA, value);
      digitalWrite(DirectionPinMotorA, HIGH);
      break;
    case 'RA':
      // motor A reverse
      analogWrite(PwmPinMotorA, value);
      digitalWrite(DirectionPinMotorA, LOW);
      break;
    case 'FB':
      // motor B forwards
      analogWrite(PwmPinMotorB, value);
      digitalWrite(DirectionPinMotorB, LOW);
      break;
    case 'RB':
      // motor B reverse
      analogWrite(PwmPinMotorB, value);
      digitalWrite(DirectionPinMotorB, HIGH);
      break;
    default:
      break;
  } 
}
 
void loop()
{
  // get a command string form the serial port
  int inputLength = 0;
  do {
    while (!Serial.available()); // wait for input
    inputBuffer[inputLength] = Serial.read(); // read it in
  } while (inputBuffer[inputLength] != LineEnd && ++inputLength < BufferLength);
  inputBuffer[inputLength] = 0; //  add null terminator
  HandleCommand(inputBuffer, inputLength);
}

//----------- End Arduino code ---------------

Processing code:

//----------- Start Processing code ----------------

import oscP5.*;
import netP5.*;
import processing.serial.*;
Serial arduinoPort;
OscP5 oscP5;

float [] fader = new float [3];

void setup() {
  oscP5 = new OscP5(this,8000);
  arduinoPort = new Serial(this, Serial.list()[0], 9600);
}

void oscEvent(OscMessage theOscMessage) {

    String addr = theOscMessage.addrPattern();
   
       if(addr.indexOf("/1/fader") !=-1){
       String list[] = split(addr,'/');
     int  xfader = int(list[2].charAt(5) - 0x30);
     if(theOscMessage.get(0).floatValue() !=0){
     fader[xfader]  = theOscMessage.get(0).floatValue();
     }  
    }
}

void draw() {
//---------------------------------Motor A
 if(fader[1] > 0.65){
    arduinoPort.write("AF100#");
  }
   if(fader[1] < 0.35){
    arduinoPort.write("AR100#");
  }
  //--------------------------------Motor B
   if(fader[2] > 0.65){
    arduinoPort.write("BF100#");
  }
   if(fader[2] < 0.35){
    arduinoPort.write("BR100#");
  }
  //----------------------------stop commands
     if(fader[1] < 0.65 && fader[1] > 0.35 ){
    arduinoPort.write("AF0#");
  }
       if(fader[2] < 0.65 && fader[2] > 0.35 ){
    arduinoPort.write("BF0#");
  }
 
}

//---------------------- End Processing Code ------------------