Sparkfun ITG-3200 Gyroscope Example Arduino Code

The official documentation and example code on Sparkfun's Site is very slightly broken and not updated for Arduino 1.0. I fixed it and sent it to them. Also posting it here:

/*

Original author: 

3/16/11

Basic Example Sketch for the ITG-3200 (http://www.sparkfun.com/products/9801)

SparkFun Electronics 2011

Ryan Owens

This code is public domain buy you buy me a beer if you use this and we meet someday (Beerware license).

-------

Updated some variables and Arduino 1.0 compatibility:

3/30/12

Daniel Gentleman

thoughtfix.com

Will take coffee in place of beer.

-------

To use this example code, attach:

Arduino  :  ITG-3200 Breakout

3.3V  :  VDD

3.3V  :  VIO

GND   :  GND

SDA   :  A4

SCL   :  A5

Load the sketch and open the serial window at 9600 bps. Arduino will output the raw X,Y and Z axis data being read from the gyroscope.

*/

//The Wire library is used for I2C communication

#include <Wire.h>

//This is a list of registers in the ITG-3200. Registers are parameters that determine how the sensor will behave, or they can hold data that represent the

//sensors current status.

//To learn more about the registers on the ITG-3200, download and read the datasheet.

char WHO_AM_I = 0x00;

char SMPLRT_DIV= 0x15;

char DLPF_FS = 0x16;

char GYRO_XOUT_H = 0x1D;

char GYRO_XOUT_L = 0x1E;

char GYRO_YOUT_H = 0x1F;

char GYRO_YOUT_L = 0x20;

char GYRO_ZOUT_H = 0x21;

char GYRO_ZOUT_L = 0x22;

//This is a list of settings that can be loaded into the registers.

//DLPF, Full Scale Register Bits

//FS_SEL must be set to 3 for proper operation

//Set DLPF_CFG to 3 for 1kHz Fint and 42 Hz Low Pass Filter

char DLPF_CFG_0 = (1<<0);

char DLPF_CFG_1 = (1<<1);

char DLPF_CFG_2 = (1<<2);

char DLPF_FS_SEL_0 = (1<<3);

char DLPF_FS_SEL_1 = (1<<4);

//I2C devices each have an address. The address is defined in the datasheet for the device. The ITG-3200 breakout board can have different address depending on how

//the jumper on top of the board is configured. By default, the jumper is connected to the VDD pin. When the jumper is connected to the VDD pin the I2C address

//is 0x69.

char itgAddress = 0x69;

//In the setup section of the sketch the serial port will be configured, the i2c communication will be initialized, and the itg-3200 will be configured.

void setup()

{

  //Create a serial connection using a 9600bps baud rate.

  Serial.begin(9600);

  

  //Initialize the I2C communication. This will set the Arduino up as the 'Master' device.

  Wire.begin();

  

  //Read the WHO_AM_I register and print the result

  char id=0; 

  id = itgRead(itgAddress, 0x00);  

  Serial.print("ID: ");

  Serial.println(id, HEX);

  

  //Configure the gyroscope

  //Set the gyroscope scale for the outputs to +/-2000 degrees per second

  itgWrite(itgAddress, DLPF_FS, (DLPF_FS_SEL_0|DLPF_FS_SEL_1|DLPF_CFG_0));

  //Set the sample rate to 100 hz

  itgWrite(itgAddress, SMPLRT_DIV, 9);

}

//The loop section of the sketch will read the X,Y and Z output rates from the gyroscope and output them in the Serial Terminal

void loop()

{

  //Create variables to hold the output rates.

  int xRate, yRate, zRate;

  //Read the x,y and z output rates from the gyroscope.

  xRate = readX();

  yRate = readY();

  zRate = readZ();

  //Print the output rates to the terminal, seperated by a TAB character.

  Serial.print(xRate);  //fixed variables here from original code. DG.

  Serial.print('\t');

  Serial.print(yRate);

  Serial.print('\t');

  Serial.println(zRate);  

  //Wait 10ms before reading the values again. (Remember, the output rate was set to 100hz and 1reading per 10ms = 100hz.)

  delay(10);

}

//This function will write a value to a register on the itg-3200.

//Parameters:

//  char address: The I2C address of the sensor. For the ITG-3200 breakout the address is 0x69.

//  char registerAddress: The address of the register on the sensor that should be written to.

//  char data: The value to be written to the specified register.

void itgWrite(char address, char registerAddress, char data)

{

  //Initiate a communication sequence with the desired i2c device

  Wire.beginTransmission(address);

  //Tell the I2C address which register we are writing to

  Wire.write(registerAddress);

  //Send the value to write to the specified register

  Wire.write(data);

  //End the communication sequence

  Wire.endTransmission();

}

//This function will read the data from a specified register on the ITG-3200 and return the value.

//Parameters:

//  char address: The I2C address of the sensor. For the ITG-3200 breakout the address is 0x69.

//  char registerAddress: The address of the register on the sensor that should be read

//Return:

//  unsigned char: The value currently residing in the specified register

unsigned char itgRead(char address, char registerAddress)

{

  //This variable will hold the contents read from the i2c device.

  unsigned char data=0;

  

  //Send the register address to be read.

  Wire.beginTransmission(address);

  //Send the Register Address

  Wire.write(registerAddress);

  //End the communication sequence.

  Wire.endTransmission();

  

  //Ask the I2C device for data

  Wire.beginTransmission(address);

  Wire.requestFrom(address, 1);

  

  //Wait for a response from the I2C device

  if(Wire.available()){

    //Save the data sent from the I2C device

    data = Wire.read();

  }

  

  //End the communication sequence.

  Wire.endTransmission();

  

  //Return the data read during the operation

  return data;

}

//This function is used to read the X-Axis rate of the gyroscope. The function returns the ADC value from the Gyroscope

//NOTE: This value is NOT in degrees per second. 

//Usage: int xRate = readX();

int readX(void)

{

  int data=0;

  data = itgRead(itgAddress, GYRO_XOUT_H)<<8;

  data |= itgRead(itgAddress, GYRO_XOUT_L);  

  

  return data;

}

//This function is used to read the Y-Axis rate of the gyroscope. The function returns the ADC value from the Gyroscope

//NOTE: This value is NOT in degrees per second. 

//Usage: int yRate = readY();

int readY(void)

{

  int data=0;

  data = itgRead(itgAddress, GYRO_YOUT_H)<<8;

  data |= itgRead(itgAddress, GYRO_YOUT_L);  

  

  return data;

}

//This function is used to read the Z-Axis rate of the gyroscope. The function returns the ADC value from the Gyroscope

//NOTE: This value is NOT in degrees per second. 

//Usage: int zRate = readZ();

int readZ(void)

{

  int data=0;

  data = itgRead(itgAddress, GYRO_ZOUT_H)<<8;

  data |= itgRead(itgAddress, GYRO_ZOUT_L);  

  

  return data;

}

Arduino, BOE Shield, PING, and a servo

The video above is in two parts: first with a crawler kit and then with wheels. Switching back to wheels required a code modification to change the time it takes to turn. 

All the parts in the video were released for the original STAMP/Propeller chips, but the code below will get you off and running on the Arduino shield. Only digital pins 10, 11, 12, and 13 are used, so any shield that does not require those pins is available for use. 

// BOE Shield code from "Robotics with the BOE Bot"

// Roaming With Whiskers source, modified to use a PING)))

// sensor on the PING))) servo bracket.

// Using code from the Ping))) example sketch.

#include <Servo.h>                           // Include servo library

Servo servoLeft;                             // Declare left, right and Ping))) servos

Servo servoRight;

Servo PingServo;

int minSafeDist = 11 ;                        // Minimum distance in inches

int pingPin = 10;                             // PING input on 10 so the last servo port is used.

int centerDist, leftDist, rightDist;          // Define distance variables

long duration, inches, cm;                    // Define variables for Ping)))

void setup()                                 // Built-in initialization block

{ 

  tone(4, 3000, 1000);                       // Play tone for 1 second

  delay(1000);                               // Delay to finish tone

  servoLeft.attach(13);                      // Attach left signal to pin 13 

  servoRight.attach(12);                     // Attach right signal to pin 12

  PingServo.attach(11);

}  

void loop(){

  LookAhead();

  if(inches >= minSafeDist) /* If the inches in front of an object is greater than or equal to the minimum safe distance (11 inches), react*/

  {

    forward (121); //Go Forward

    delay(110); // Wait 0.11 seconds

  }

  else // If not:

  {

    servoLeft.writeMicroseconds(1500);

    servoRight.writeMicroseconds(1500);

    LookAround(); // Check your surroundings for best route

    if(rightDist > leftDist) // If the right distance is greater than the left distance , turn right

    {

      turnRight (250); // Turn Right      

    }

    else if (leftDist > rightDist) // If the left distance is greater than the right distance , turn left

    {

      turnLeft (250); // Turn Left

    }

    else

    {

      backward (250); // Go Backward

    }

    delay (250);

  }

}

void forward(int time)                       // Forward function

{

  servoLeft.writeMicroseconds(1700);         // Left wheel counterclockwise

  servoRight.writeMicroseconds(1300);        // Right wheel clockwise

  delay(time);                               // Maneuver for time ms

}

void turnLeft(int time)                      // Left turn function

{

  servoLeft.writeMicroseconds(1300);         // Left wheel clockwise

  servoRight.writeMicroseconds(1300);        // Right wheel clockwise

  delay(time);                               // Maneuver for time ms

}

void turnRight(int time)                     // Right turn function

{

  servoLeft.writeMicroseconds(1700);         // Left wheel counterclockwise

  servoRight.writeMicroseconds(1700);        // Right wheel counterclockwise

  delay(time);                               // Maneuver for time ms

}

void backward(int time)                      // Backward function

{

  servoLeft.writeMicroseconds(1300);         // Left wheel clockwise

  servoRight.writeMicroseconds(1700);        // Right wheel counterclockwise

  delay(time);                               // Maneuver for time ms

}

unsigned long ping() {

  pinMode(pingPin, OUTPUT);

  digitalWrite(pingPin, LOW); //Send a low pulse

  delayMicroseconds(2); // wait for two microseconds

  digitalWrite(pingPin, HIGH); // Send a high pulse

  delayMicroseconds(5); // wait for 5 micro seconds

  digitalWrite(pingPin, LOW); // send a low pulse

  pinMode(pingPin,INPUT); // switch the Pingpin to input

  duration = pulseIn(pingPin, HIGH); //listen for echo

  /*Convert micro seconds to Inches

   -------------------------------------*/

  cm = microsecondsToCentimeters(duration);

  inches = microsecondsToInches(duration);

}

long microsecondsToInches(long microseconds) // converts time to a distance

{

  return microseconds / 74 / 2;

}

long microsecondsToCentimeters(long microseconds) // converts time to a distance

{

  return microseconds / 29 / 2;

}

void LookAhead() {

  PingServo.write(90);// angle to look forward

  delay(175); // wait 0.175 seconds

  ping();

}

void LookAround(){

  PingServo.write(20); // 20° angle

  delay(320); // wait 0.32 seconds

  ping();

  rightDist = inches; //get the right distance

  PingServo.write(160); // look to the other side

  delay(620); // wait 0.62 seconds

  ping(); 

  leftDist = inches; // get the left distance

  PingServo.write(90); // 90° angle

  delay(275); // wait 0.275 seconds

}

Sparkfun RGB LED and RGB Light Sensor

I can't quite figure this one out: it's VERY delicate and I can't get consistant color results with the built-on LED on or off. I know if it gets a UV light, it shows a lot of purple and if it gets hit with a red laser it maxes out the red LED. Anyhow... Video and code! 

/*

Expanded to use the Sparkfun RGB LED on pins 3, 5, and 6, sending

PWM signals as 1/10 of the result. YouTube video of this in action at

Use of the RGB LED changes added by thoughtfix 2/2012

Inherited OSHW license.

Original comments below.

*/

/*

An Arduino code example for interfacing with the 

HDJD-S822-QR999 Color Sensor.  Put an object in front of the

sensor and look at the serial monitor to see the values the sensor

is reading.  Scaling factors and gains may have to be adjusted

for your application.

by: Jordan McConnell

 SparkFun Electronics

 created on: 1/24/12

 license: OSHW 1.0, http://freedomdefined.org/OSHW

 

Connect the gain pins of the sensor to digital pins 7 - 12 (or ground).

Connect the led pin to digital 13.

Connect Vr to analog 0, Vg to analog 1, and Vb to analog 2.

*/

// Define pins

const int ledpin = 13;

const int GSR1 = 12;

const int GSR0 = 11;

const int GSG1 = 10;

const int GSG0 = 9;

const int GSB1 = 8;

const int GSB0 = 7;

const int redLed = 3;

const int greenLed = 5;

const int blueLed = 6;

int redpin = A0;

int greenpin = A1;

int bluepin = A2;

// Sensor read values

int red = 0;

int green = 0;

int blue = 0;

int redBright = 0;

int greenBright = 0;

int blueBright = 0;

void setup() 

{

  Serial.begin(9600);

  pinMode(ledpin, OUTPUT);

  pinMode(GSR1, OUTPUT);

  pinMode(GSR0, OUTPUT);

  pinMode(GSG1, OUTPUT);

  pinMode(GSG0, OUTPUT);

  pinMode(GSB1, OUTPUT);

  pinMode(GSB0, OUTPUT);

  pinMode(redLed, OUTPUT);

  pinMode(greenLed, OUTPUT);

  pinMode(blueLed, OUTPUT);

  // Turn on the LED

  digitalWrite(ledpin, LOW);

  

  // Set the gain of each sensor

  digitalWrite(GSR1, LOW);

  digitalWrite(GSR0, LOW);

  digitalWrite(GSG1, LOW);

  digitalWrite(GSG0, LOW);

  digitalWrite(GSB1, LOW);

  digitalWrite(GSB0, LOW);

}

void loop() 

{

  

  // Read sensors

  // On page 7 of the datasheet, there is a graph of the 

  // spectral responsivity of the chip.  Scaling factors were

  // selected based on this graph so that the gain of each 

  // color is closer to being equal

  red = analogRead(redpin) * 10;

  green = analogRead(greenpin) * 14;

  blue = analogRead(bluepin) * 17;

  redBright = red/10;

  greenBright = green/10;

  blueBright = blue/10;

  // Print values to the serial monitor

  Serial.print("Red: ");

  Serial.print(red, DEC);

  analogWrite(redLed, redBright);

  Serial.print("\t\tGreen: ");

  Serial.print(green, DEC);

  analogWrite(greenLed, greenBright);

  Serial.print("\tBlue: ");

  Serial.println(blue, DEC);

  analogWrite(blueLed, blueBright);

  delay(20);

}

/*Expanded to use the Sparkfun RGB LED on pins 3, 5, and 6, sendingPWM signals as 1/10 of the result. YouTube video of this in action at
Use of the RGB LED changes added by thoughtfix 2/2012Inherited OSHW license.Original comments below.*/
/*An Arduino code example for interfacing with the HDJD-S822-QR999 Color Sensor.  Put an object in front of thesensor and look at the serial monitor to see the values the sensoris reading.  Scaling factors and gains may have to be adjustedfor your application.
by: Jordan McConnell SparkFun Electronics created on: 1/24/12 license: OSHW 1.0, http://freedomdefined.org/OSHW Connect the gain pins of the sensor to digital pins 7 - 12 (or ground).Connect the led pin to digital 13.Connect Vr to analog 0, Vg to analog 1, and Vb to analog 2.*/

// Define pinsconst int ledpin = 13;const int GSR1 = 12;const int GSR0 = 11;const int GSG1 = 10;const int GSG0 = 9;const int GSB1 = 8;const int GSB0 = 7;const int redLed = 3;const int greenLed = 5;const int blueLed = 6;
int redpin = A0;int greenpin = A1;int bluepin = A2;
// Sensor read valuesint red = 0;int green = 0;int blue = 0;int redBright = 0;int greenBright = 0;int blueBright = 0;
void setup() {  Serial.begin(9600);
  pinMode(ledpin, OUTPUT);  pinMode(GSR1, OUTPUT);  pinMode(GSR0, OUTPUT);  pinMode(GSG1, OUTPUT);  pinMode(GSG0, OUTPUT);  pinMode(GSB1, OUTPUT);  pinMode(GSB0, OUTPUT);  pinMode(redLed, OUTPUT);  pinMode(greenLed, OUTPUT);  pinMode(blueLed, OUTPUT);
  // Turn on the LED  digitalWrite(ledpin, LOW);    // Set the gain of each sensor  digitalWrite(GSR1, LOW);  digitalWrite(GSR0, LOW);  digitalWrite(GSG1, LOW);  digitalWrite(GSG0, LOW);  digitalWrite(GSB1, LOW);  digitalWrite(GSB0, LOW);}
void loop() {    // Read sensors  // On page 7 of the datasheet, there is a graph of the   // spectral responsivity of the chip.  Scaling factors were  // selected based on this graph so that the gain of each   // color is closer to being equal  red = analogRead(redpin) * 10;  green = analogRead(greenpin) * 14;  blue = analogRead(bluepin) * 17;  redBright = red/10;  greenBright = green/10;  blueBright = blue/10;
  // Print values to the serial monitor  Serial.print("Red: ");  Serial.print(red, DEC);  analogWrite(redLed, redBright);  Serial.print("\t\tGreen: ");  Serial.print(green, DEC);  analogWrite(greenLed, greenBright);  Serial.print("\tBlue: ");  Serial.println(blue, DEC);  analogWrite(blueLed, blueBright);  delay(20);}

2WD Roving Robot

This is a simple robot using an Adafruit Motor Shield, Arduino Uno, and two motors. The video shows off the sensors and arrangements. The source code is below:

/*
Autonomous roving robot
Parts: 
   -Arduino Uno
   -Parallax PING))) ultrasonic sensor
   -Adafruit motor shield http://www.ladyada.net/make/mshield/
   -2WD Mobile Platform http://www.makershed.com/ProductDetails.asp?ProductCode=MKSEEED7
   -Lever switch (for back bumper)
   -Indicator LED
   -Energizer XPAL XP8000 battery (custom cable and self-built regulator for motors)
Original motion functions and design from Robot Living 8/30/2010 
Code borrowed from example sketches:
   -Ping
Original code created June 2011
by Daniel Gentleman
thoughtfix@gmail.com
http://thoughtfix.com

Additional credits: 
Victor Brilon
Mark Balliet
luckylarry.co.uk for the math on the Sharp sensor
Advice from arduino.cc forum
Advice from from #arduino on irc.freenode.net
Advice from adafruit forums
Further inspiration
      -Adafruit Industries
      -Make Magazine
Adafruit Motor shield library

Wiring (remember, analog 0 is also digital 14) 
- Left motor to Motor 1
- Right motor to Motor 2
- LEDs on digital 15 and 16
- PING))) on digital 17
- Sharp IR sensors on digital 18 and 19
- Lever switch (bumper attached) on digital 14
- USB power (from a USB battery) to the Arduino
- Regulated power (I used an Energizer XPAL XP8000 regulated to +5v) for servos
*/


#include <AFMotor.h>

AF_DCMotor motorL(1, MOTOR12_1KHZ);
AF_DCMotor motorR(2, MOTOR12_1KHZ);


int BSensor = 14; //Back sensor
int FLEDPin = 15; //Forward LED
int BLEDPin = 16; //Backup LED
int pingPin = 17; //Front sensor
int FSensorR = 18; //Front right sensor
int FSensorL = 19;  //Front left sensor
int count = 0;
int b=0;
int bs=0;
int sensorValue;
int forwardSensor;
int sensorValueB=1;
int leftSensor=0;
int rightSensor=0;
int obstacle=0;


void setup() {
  Serial.begin(9600); 
  randomSeed(analogRead(0));
  pinMode(BLEDPin, OUTPUT); 
  pinMode(FLEDPin, OUTPUT);
  pinMode(BSensor, INPUT);
  pinMode(pingPin, INPUT);
  pinMode(FSensorR, INPUT);
  pinMode(FSensorL, INPUT);
  motorL.setSpeed(200);
  motorR.setSpeed(200);
  motorL.run(RELEASE);
  motorR.run(RELEASE);
}

void loop()
{
  uint8_t i;
  Forward();
}

void Forward () // Charge forth!
{
  digitalWrite(FLEDPin, HIGH);                
  digitalWrite(BLEDPin, LOW);
  ForwardSensor ();
  if (obstacle == 0){ //unless something is in the way
  Serial.println("Going forward.");
  motorL.run(FORWARD);
  motorR.run(FORWARD);
  }

}

void ForwardSensor ()
{
  leftSensor = (ForwardSensorLeft());
  rightSensor =(ForwardSensorRight());
  forwardSensor = (getDistance());
  delay(30);
  //  Serial.print(leftSensor);
  //  Serial.println(" left");
  //  Serial.print(rightSensor);
  //  Serial.println(" right");
  //  Serial.print(forwardSensor);
  //  Serial.println(" front");
  if (forwardSensor <=30 || leftSensor <= 30 || rightSensor <= 30 )
  { // I gave 10cm of "wiggle room" so it doesn't turn endlessly. 
    obstacle=1;
    if (ForwardSensorRight() > (ForwardSensorLeft()-10)){
      RightBackward();
    }
    else if (ForwardSensorRight() < (ForwardSensorLeft()-10)){
      LeftBackward();
    }
    else{
      Backward();
    }
  }
  else {
    obstacle = 0;
  }
  sensorValue=0;
  rightSensor=0;
  leftSensor=0;
}

int ForwardSensorRight () 
{ // This function is here so you don't have to re-write code
  // if you use a different sensor.
  sensorValue = irDistance(FSensorR); 
  return sensorValue;
}

int ForwardSensorLeft ()
{ // This function is here so you don't have to re-write code
  // if you use a different sensor.
  sensorValue = irDistance(FSensorL); 
  return sensorValue;
}

void BackwardSensor ()
{
  sensorValueB = digitalRead(BSensor); 
  if (sensorValueB == 1)
  {
    Serial.println("Object detected while going backwards.");
    motorL.run(RELEASE);
    motorR.run(RELEASE);
    for (bs=0; bs <= 3; bs++) // Add blinky lights for personality on detecting object when backing up.
    {
      digitalWrite(FLEDPin, HIGH);                
      digitalWrite(BLEDPin, HIGH);
      delay(5);
      digitalWrite(FLEDPin, LOW);                
      digitalWrite(BLEDPin, LOW);
      delay (5);
    }
    b=31;
    bs=0;
    Forward();

  }
  sensorValueB = 0;
}

void Backward ()
{
  motorL.run(RELEASE);
  motorR.run(RELEASE);
  digitalWrite(FLEDPin, LOW);                
  digitalWrite(BLEDPin, HIGH);
  Serial.println("Going backwards.");

  do
  {
    b++;
    motorL.run(BACKWARD);
    motorR.run(BACKWARD);
    delay(20);
    BackwardSensor ();
  } 
  while (b < 20);

  b=0;
}


void LeftBackward ()
{
  motorL.run(RELEASE);
  motorR.run(RELEASE);
  digitalWrite(FLEDPin, LOW);                
  digitalWrite(BLEDPin, HIGH);
  Serial.println("Going left backwards.");

  do
  {
    b++;
    //    Serial.print("b = ");
    //    Serial.print(b);
    motorL.run(BACKWARD);
    motorR.run(RELEASE);
    BackwardSensor ();
    delay (20);
  } 
  while (b < 20);

  b=0;
}

void RightBackward ()
{
  motorL.run(RELEASE);
  motorR.run(RELEASE);
  digitalWrite(FLEDPin, LOW);                
  digitalWrite(BLEDPin, HIGH);
  Serial.println("Going right backwards.");

  do
  {
    b++;
    //    Serial.print("b = ");
    //    Serial.print(b);
    motorL.run(RELEASE);
    motorR.run(BACKWARD);
    BackwardSensor ();
    delay (20);
  } 
  while (b < 20);

  b=0;
}

int getDistance()
{ 
  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
reread:  // takes another reading if cm=0
  long duration, cm;
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);
  // The same pin is used to read the signal from the PING))): a HIGH
  // pulse whose duration is the time (in microseconds) from the sending
  // of the ping to the reception of its echo off of an object.
  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);

  // convert the time into a distance
  cm = microsecondsToCentimeters(duration);
  //  Serial.print(cm);
  //  Serial.print("cm");
  //  Serial.println();
  delay(100);
  //  if (cm == 0) {
  //    goto reread;
  //  }
  return cm;
} 

long microsecondsToCentimeters(long microseconds)
{
  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the
  // object we take half of the distance travelled.
  return (microseconds/58);
}

int irDistance(int irPin) {
  float volts = analogRead(irPin)*0.0048828125;   // value from sensor * (5/1024) - if running 3.3.volts then change 5 to 3.3
  int distance = 32.5*pow(volts, -1.10);          // theretical distance 32.5/ (1/Volts)S 
  //  Serial.print(distance);
  //  Serial.print(" from ");
  //  Serial.println(irPin);  
  delay (10);
  return distance;        // print the raw analog value to serial port
}

Twitter-posting Kitty Dishes

For Adafruit/Instructables "Make it Tweet" challenge, I assembled a way for an Arduino microcontroller to monitor and post updates to Twitter when the cats eat, need food, and need water. Here's an overview video:

The complete project is posted on instructables, complete with source code and schematics.