Connecting to Sparkfun’s 9DOF “Sensor Stick”: I2C access to ADXL345, ITG-3200, and HMC5843

[Update 24 Aug 2012: This post gives good detail about how to communicate with the sensors on the 9DoF Sensor Stick, but if you want a cleaner solution (that has been updated for Arduino 1.0), have a look at this post.]

Accelerometers are fun, but I want something more.  So I picked up a “sensor stick” from Sparkfun.

Sparkfun’s 9DOF sensor stick. Image courtesy of Sparkfun Electronics is CC by NC-SA 3.0

It has an ADXL345 accelerometer (datasheet) , an ITG-3200 gyroscope (datasheet), and an HMC5843 magnetometer (datasheet).  When still, the accelerometer can read the local gravitational field and the magnetometer can read the local magnetic field.  As long as I’m not at a magnetic pole, this is enough to give me an external frame of reference and know exactly how my sensor is positioned in space.  When the device is spinning, the gyro can help me separate translational acceleration from rotational acceleration as well as help me keep a running estimate of my sensor’s orientation even when I can’t trust the acceleration.  A system that does this is called an Attitude and Heading Reference System [AHRS].

I’m just getting into the Mathematics of how to use all of this data, and it is going to be good fun.  For today I’m going to talk about a much simpler problem: how do you connect to this board, initialize it, and read data from it.

Reading nine analog measurements directly would require nine analog pins, something we don’t have.  Instead, we will access these sensors using I2C, a two-wire protocol that allows us to put up to 112 devices on one bus.  This makes the wiring simple and the programming just a touch more tedious.

There are loads of great introductions to I2C on the web.  I may add to them one day, but for now, use your favorite search engine and learn about it if you don’t already know.

Building the Circuit

First things first, I soldered wires to my sensor stick instead of the plugable headers I usually work with.  I figured it would be more flexible if I wanted to stick it on a ski or sew it into my clothing later.  This is what my stick looks like:

My sensor stick, prepped and ready to go.

Thanks to I2C, our circuit is dead simple.  We just need the following connections to get this going on an Arduino Uno:

1. Sensor stick VCC -> Arduino 3.3V
2. Sensor stick GND -> Arduino GND
3. Sensor stick SDA -> Arduino A4 (Arduino’s SDA, or data line)
4. Sensor stick SCL  -> Arduino A5  (Arduino’s SCL, or clock line)

Here’s a Fritzing diagram in case the words are too complicated…

Once the circuit is put together, you are ready to start programming.

Reading data from the sensor stick

In order to access the sensor stick, we will need to

1. know the 7-bit I2C addresses for each of our sensors
2. know the addresses of each register we need to access on each sensor
3. know how to initialize the sensors to make sure they are recording data, configured as we want them, and not sitting in power save mode.
4. start reading data

Steps 1-3 require spending some quality time with the datasheets (linked above) and the schematic of the sensor stick so you know which pins are being pulled to GND, etc. Or you can just copy my code below.

I’ll walk through code for steps 1-3 for each of the three sensors before putting it all together in a simple data collection loop.

All I2C access will be done using the Wire library, so put this line at the top of your sketch:

#include <Wire.h>

I also use these two utility functions to interact with the I2C bus throughout the code.  This is really all there is to I2C on Arduino if your needs are simple.  These methods are based on ones I found on Keith Neufeld’s blog.

void i2c_write(int address, byte reg, byte data) {
  // Send output register address
  Wire.beginTransmission(address);
  Wire.send(reg);
  // Connect to device and send byte
  Wire.send(data); // low byte
  Wire.endTransmission();
}

void i2c_read(int address, byte reg, int count, byte* data) {
 int i = 0;

 // Send input register address
 Wire.beginTransmission(address);
 Wire.send(reg);
 Wire.endTransmission();
 // Connect to device and request bytes
 Wire.beginTransmission(address);
 Wire.requestFrom(address,count);
 while(Wire.available()) // slave may send less than requested {
   char c = Wire.receive(); // receive a byte as character
   data[i] = c;
   i++;
 }
 Wire.endTransmission();
}

Accessing the ADXL345 accelerometer

Per the datasheet, the 8-bit address for the ADXL345 is 0x3A unless pin 12 is pulled to GND, then it is 0xA6.  A quick look at the schematic shows that pin 12 is indeed pulled low, so our address is 0xA6.  (Don’t ask how long I kept trying and failing to use 0x3A!)

The Wire library just wants a 7-bit address, so we right shift and add this line to our code:

#define  ADXL345_ADDRESS (0xA6 >> 1)

There are a couple of register addresses we need to access:

//There are 6 data registers, they are sequential starting 
//with the LSB of X.  We'll read all 6 in a burst and won't
//address them individually
#define ADXL345_REGISTER_XLSB (0x32)

 //Need to set power control bit to wake up the adxl345
 #define ADXL_REGISTER_PWRCTL (0x2D)
 #define ADXL_PWRCTL_MEASURE (1 << 3)

With these definitions in place, this is how we initialize the ADXL345 on startup:

void init_adxl345() {
  byte data = 0;

  i2c_write(ADXL345_ADDRESS, ADXL_REGISTER_PWRCTL, ADXL_PWRCTL_MEASURE);

  //Check to see if it worked!
  i2c_read(ADXL345_ADDRESS, ADXL_REGISTER_PWRCTL, 1, &data);
  Serial.println((unsigned int)data);
}

Once the accelerometer is initialized we can read the data.  It comes to us in a chunk of 6 bytes: the least significant byte of X, the most significant byte of X, the least significant byte of Y, the most significant byte of Y, and so on.  Here’s the code.

int accelerometer_data[3];

void read_adxl345() {
 byte bytes[6];
 memset(bytes,0,6);

 //read 6 bytes from the ADXL345
 i2c_read(ADXL345_ADDRESS, ADXL345_REGISTER_XLSB, 6, bytes);

 //now unpack the bytes
 for (int i=0;i<3;++i) {
 accelerometer_data[i] = (int)bytes[2*i] + (((int)bytes[2*i + 1]) << 8);
 }
}

Accessing the ITG-3200 gyro

Perusing the datasheet and schematic like we did above, we find that the ITG-3200 has 8-bit address 0xD0.  To get reasonable data from it, we must also initialize the scale and digital low-pass filter.  This is critical: the default value for the scale on startup is 0b00, a reserved value!  Here are the definitions we need:

#define ITG3200_ADDRESS (0xD0 >> 1)
//request burst of 6 bytes from this address
#define ITG3200_REGISTER_XMSB (0x1D)
#define ITG3200_REGISTER_DLPF_FS (0x16)
#define ITG3200_FULLSCALE (0x03 << 3)
#define ITG3200_42HZ (0x03)

And here is the initialization function

void init_itg3200() {
  byte data = 0;

  //Set DLPF to 42 Hz (change it if you want) and
  //set the scale to "Full Scale"
  i2c_write(ITG3200_ADDRESS, ITG3200_REGISTER_DLPF_FS, ITG3200_FULLSCALE | ITG3200_42HZ);

  //Sanity check! Make sure the register value is correct.
  i2c_read(ITG3200_ADDRESS, ITG3200_REGISTER_DLPF_FS, 1, &data);

  Serial.println((unsigned int)data);
}

Once initialized, we can use the following function to capture the data.  Notice that the most-significant and least-significant bits come in a different order than they did with the ADXL345.

int gyro_data[3];

void read_itg3200() {
  byte bytes[6];
  memset(bytes,0,6);

  //read 6 bytes from the ITG3200
  i2c_read(ITG3200_ADDRESS, ITG3200_REGISTER_XMSB, 6, bytes);  //now unpack the bytes
  for (int i=0;i<3;++i) {
  gyro_data[i] = (int)bytes[2*i + 1] + (((int)bytes[2*i]) << 8);
  }
}

Accessing the HMC5843

Now let’s do the same work for our magnetometer, the HMC5843.  The trick with this one is that by default it starts in a single measurement mode.  If you don’t change that, you’ll just keep getting the same reading over and over.

#define HMC5843_ADDRESS (0x3C >> 1)
//First data address of 6 is XMSB.  Also need to set a configuration register for
//continuous measurement
 #define HMC5843_REGISTER_XMSB (0x03)
 #define HMC5843_REGISTER_MEASMODE (0x02)
 #define HMC5843_MEASMODE_CONT (0x00)

The initialization just sets the measurement mode.

void init_hmc5843() {
  byte data = 0;
  //set up continuous measurement
  i2c_write(HMC5843_ADDRESS, HMC5843_REGISTER_MEASMODE, HMC5843_MEASMODE_CONT);

  //Sanity check, make sure the register value is correct.
  i2c_read(HMC5843_ADDRESS, HMC5843_REGISTER_MEASMODE, 1, &data);
  Serial.println((unsigned int)data);
}

With this done, we can now read the data registers,  almost exactly like we did for the gyro.

int magnetometer_data[3];
void read_itg3200() {
 byte bytes[6];
 memset(bytes,0,6);

  //read 6 bytes from the HMC5843
 i2c_read(HMC5843_ADDRESS, HMC5843_REGISTER_XMSB, 6, bytes);

  //now unpack the bytes
 for (int i=0;i<3;++i) {
 magnetometer_data[i] = (int)bytes[2*i + 1] + (((int)bytes[2*i]) << 8);
 }
}

Putting it all together

First let’s perform all of the initialization we need on setup:

 void setup() {
  Wire.begin();
  Serial.begin(9600);

  for(int i = 0; i < 3; ++i) {
    accelerometer_data[i] = magnetometer_data[i] = gyro_data[i] = 0;
  }

  init_adxl345();
  init_hmc5843();
  init_itg3200();
}

Now that all of the hard work is done, a simple little loop can hum away and report all of your raw data for you:

 void loop() {
   read_adxl345();

   Serial.print("ACCEL: ");
   Serial.print(accelerometer_data[0]);
   Serial.print("\t");
   Serial.print(accelerometer_data[1]);
   Serial.print("\t");
   Serial.print(accelerometer_data[2]);
   Serial.print("\n");

   read_hmc5843();

   Serial.print("MAG: ");
   Serial.print(magnetometer_data[0]);
   Serial.print(",");
   Serial.print(magnetometer_data[1]);
   Serial.print(",");
   Serial.print(magnetometer_data[2]);
   Serial.print("\n");

   read_itg3200();

   Serial.print("GYRO: ");
   Serial.print(gyro_data[0]);
   Serial.print("\t");
   Serial.print(gyro_data[1]);
   Serial.print("\t");
   Serial.print(gyro_data[2]);
   Serial.print("\n");

   //Sample at 10Hz
   delay(100); }

Of course once you run this and play with it for a while, you’re going to ask “Now how do I calibrate these things?”  

Well, the Gauss-Newton method I’ve been beating on in my earlier posts works great for the ADXL345 (of course) and the HMC5843.  For the gyro it’s a different story and I’m working on it.

I’ll try to get a full sensor stick sketch with calibration up some time soon too.  In the mean time, have fun checking your attitude.

UPDATE: If you want a quick and easy way to visualize your raw data to make sure it is reasonable and perhaps do a quick “hand calibration” (not that I’d ever do such a thing 🙂 then have a look at this post and try out the gnuplot scripts.  Here’s what my magnetometer data looked like after spinning the stick around haphazardly for a while:

Four views of raw magnetometer data collected from the Sparkfun sensor stick

It is very close to an ellipsoid, and I was able to run this raw data through my Gauss-Newton octave scripts (described in the accelerometer calibration series)  to calibrate the magnetometer beautifully.