Have you gotten your robot to go towards the vision tetra?

[Tom Bottiglieri]

There is a few things that can be helpful to use while tracking color using camera_find_color().

Ill give a quick run down of how this works. The camera processor can send and receive messages through the serial port. If you look in the camera manual PD, you will see a complete list of commands and their parameters. The one we are interested in is "TC" (track color) You send the camera this command followed by the max and min RB values.

This is the format of the Track Color Command:
TC [ Rmin Rmax Gmin Gmax Bmin Bmax ] r

Now, the camera processor takes over. Using the max and min RGB values (which you found in calibration), it looks for a color blob which has pixels that fit into the RGB value window you have specified (once again, with calibration) If the does not find a color, it will return a 0. If the camera does find your color, it will return what is called a 't packet' This serial packet includes information about the color blob's Centroid coordinates, bounding box (how big of an area it covers), amount of pixels tracked, and a certainty rating (0-100%, how sure the camera is this is YOUR blob)

Once the camera finds the blob, it goes into frame differencing mode. In this mode, the camera records many frames per second, in a very small resolution. It then can determine whether the color blob has moved over time. It will compute how far the blob has moved to either the left or right, and since the camera board has control of a pan servo, it will try to correct itself, so that the blob's centroid is in the exact center of the frame.

Now, you may be asking what you can do with this information...

The camera driver sets up a structure, from which you can grab different values. When camera_track_update( ) is called, it will take the last good T packet and throw the data into local variables. It also grabs the current servo angles (pwm values) and throws those into RC local variables. Now, you have exactly what the camera is seeing in variables on the RC, which can be accessed by referencing the "cam" object. So to get the pan servo's pwm value, all you would need to do in your code is include the cam structure, and then use that structures variable 'pan_servo'

This is how you can do that:

extern cam_struct cam; //include cam structure in your NEW, not default code.

//set local reference to latest cam data
camera_track_update( );  
TheServo = cam.pan_servo;

Now, you know what angle the blob is in relation to the front of the bot (from the servo angle) You can now adjust the bots heading according to this. If the blob is to the left of the bot, rotate left. To the right, rotate right. Now when your bot is 0^o with the blobl, you are safe to drive forward.

So (in very basic form), this is how to track a color, in code form.

int SPEED_SETTING = 155; //Set how fast you want bot to drive/turn.
int centered = 0;   //use this to check if bot is alligned with blob.
int tracking = 0;    //use this to see if we got a good frame.

//set camera to track your color, lets say green.
tracking = camera_find_color( GREEN );

//update camera info
camera_track_update( );

//See if bot is facing blob. If not, correct.

if(cam.pan_servo < 120) //im using a 7 value deadband.
{
     wheel_l = 255 - SPEED_SETTING;
     wheel_r = SPEED_SETTING;      // This turns bot to the left.
     centered = 0;
}
else if(cam.pan_servo > 134)
{
     wheel_l = SPEED_SETTING;
     wheel_r = 255 - SPEED_SETTING;     //This turns bot to right.
     centered = 0;
}
else centered = 1;

//Now check to see if theres a good frame, and if the servo blob is in front of the bot. If there is, drive to it.

if(tracking == 1 && centered==1)
{
     wheel_l = SPEED_SETTING;
     wheel_l = SPEED_SETTING; //Drive straight!
}

Now that will bring you into basic color tracking. The next logical thing to do would be to stop when you are close to a color. To this, you may use a tilt servo, which does the same thing as the pan servo (in which it tries to center the color blob; meaning.. the tilt servo would be pointing directly at your color's centroid) If you know the tilt servos angle, you can do some basic trig to find out how far the color is away.



Another way you could find how far away the blob is by looking at the bounding box, and comparing its values.

If I get some good feedback, I will write a white paper explaining the camera more in depth and giving more example code.

Hope this helped,
Tom.