Getting Started with Accelerometers and Micro-controllers: Arduino + ADXL335

My first home electronics project — a device to measure leg acceleration and balance while skiing — involved connecting an ADXL335 on a Sparkfun breakout board to an Arduino Uno.  Going in, I was an experienced programmer but knew nothing about electronics.  The online resources are good, but I found some important information was missing.  Some of it seems like stuff that just goes without saying in the community, but I’m going to go ahead and say it to save other newbies like myself any trouble.

So this is the post I wish I had found before I started working with the ADXL335.  I will assume that:

• you know how to build simple circuits
• you know how to write and upload a sketch
• you know how to open the serial monitor

If you can’t do any of these things, go spend an hour playing with some of the basic examples at arduino.cc then come back here.

To get an ADXL335 talking to an Arduino, there is not much to do.  Here are the key steps:

1. Solder pins to the breakout board or do something else to get a good connection.
2. Build the circuit with 3.3V power and AREF to normalize the analog input.
3. Write a basic sketch.
4. Calibrate.

Let me elaborate.

1. Solder header pins to the breakout board (or do something else to get a good connection)

I had no idea I needed to do this, and I never read anything that told me I needed to do this.  This is one of those things that goes without saying.

When I got my breakout board in the mail, I thought all I needed to do was make sure I got wires touching those little holes in the board when I built my circuit, so I got a 6-pin header and plugged it in to the breakout board.

I got lousy data that bounced around and didn’t change noticeably when I moved the thing around and tilted it.  I thought I built the circuit wrong, but it was so simple.   Or maybe I had damaged the component?

Then I tried connecting wires in to the breakout board directly.  No luck.

Finally I noticed that all of the pictures of this thing I’d seen online had the headers soldered in.  Could that be it?

I bought a soldering iron and tried it.

6-pin header soldered crookedly on an ADXL335 breakout board. I need a better camera for this stuff.

It was my first soldering job, so it wasn’t pretty, but the data was beautiful.  It looked just like the examples I had seen online.

So do this before you bother building your circuit.

[There are other ways to get good connections — pogo pins for example — but do something to make sure you have a solid physical connection.]

2. Build the circuit with 3.3V power and AREF

This is something I was surprised about.  Many of the online examples I found for the ADXL335 and Arduino hooked the accelerometer up to 5V power even though the data sheet explicitly says not to exceed 3.6V.

It is easy enough to wire VCC to the 3.3V pin on the Arduino, but then you lose some of the resolution on your analog input because the analog-to-digital converter expects input up to 5V.

So you need to run a wire from 3.3V over to the AREF pin to.  Here is what my basic circuit looks like:

A basic circuit for interaction with an ADXL335 on a breakout board.

This image was produced with Fritzing.  Here is what my circuit looks like in real life:

A real life version of the circuit. It's much easier to understand a fritzing image.

This also requires changes to the code in your sketch.  So let’s talk about that now.

3. Write a sketch

The example sketch that shipped with my installation of the Arduino is based on a clever circuit that skips the breadboard and plugs the ADXL335 directly into the pins A0-A5 on the Arduino.  I like that setup except for one thing: It runs 5V power to my ADXL.  So I’ll write my own code to work with the circuit shown above.

First, define a few constants to make what follows easier to read, expand,  and maintain.  All we need to do here is define our input pins and a parameter that we use to set the time between samples.

// these constants describe the pins. They won't change:
const int xpin = A1;                  // x-axis of the accelerometer
const int ypin = A2;                  // y-axis
const int zpin = A3;                  // z-axis (only on 3-axis models)

int sampleDelay = 500;   //number of milliseconds between readings

Now write the setup routine.  Here we need to:

1. Initialize serial communication
2. Tell the analog-to-digital converter to use an external reference voltage (which comes in on the AREF pin).
3. Set up our input pins.

It looks like this:

void setup()
{
  // initialize the serial communications:
  Serial.begin(9600);

  //Make sure the analog-to-digital converter takes its reference voltage from
  // the AREF pin
  analogReference(EXTERNAL);

  pinMode(xpin, INPUT);
  pinMode(ypin, INPUT);
  pinMode(zpin, INPUT);
}

Finally, in our loop routine we simply read the pins, write the values to serial, then wait a little bit.

void loop()
{

  Serial.print( analogRead(xpin));
  Serial.print("\t");

  //add a small delay between pin readings.  I read that you should
  //do this but haven't tested the importance
    delay(1); 

  Serial.print( analogRead(ypin));
  Serial.print("\t");
  //add a small delay between pin readings.  I read that you should
  //do this but haven't tested the importance
    delay(1); 

  Serial.print( analogRead(zpin));
  Serial.print("\n");  // delay before next reading:
  delay(sampleDelay);
}

A sketch doesn’t get much simpler than this.  Once you build your circuit and upload this sketch, open up the serial monitor and you should start seeing data that looks something like this:

512  506  620
512  506  620
513  506  620
...

The higher voltage coming off of the z pin (the third column) is measuring the acceleration of gravity: 1 G in (almost) the positive z direction.  Flip the breadboard over and you’ll see something like this:

515  506  413
516  508  416
515  508  411
...

Now the z-pin gives a low voltage indicating the acceleration of gravity is now in the negative z direction.  If you are holding it in your hand, you’ll see the values bounce around a lot more than they do when it is sitting on a table.  Flip it around, tilt it different ways, shake it.  See what happens.

4. Calibrate the input

Now that you have the basic circuit up and running, you can see how tilt and acceleration are changing the voltages coming  out of your accelerometer, but things aren’t quite right.  What exactly do those numbers mean?

Reading the ADXL335 datasheet we see that on 3.3V power, we should expect an axis to read 1.65V when it has zero acceleration, and the voltage should typically change by 330 mV per G of acceleration.  The signal from our analog to digital converter gives us a number from 0 to 1023.   I’ll call these “ADC units”.  0V maps to 0 ADC units, 3.3V maps to 1023 ADC units and I assume it is linear in between.

This means that zero acceleration on an axis should give us a reading of 512 ADC units on the pin for that axis.  Also, a change of 1 ADC unit in our signal corresponds to a voltage difference of 3.3V/1023 ADC units = 3.226 mV/ADC unit.  Since the datasheet says 1G typically corresponds to  330 mV voltage difference, we expect that

330 mV/G = 330 mV/G × (1023 ADC units) / 3.3 V = 102.3 (ADC units)/G

We can use this to transform our signal into Gs.  To do it, change your loop() routine to look like this

void loop()
{
  int x = analogRead(xpin);

  //add a small delay between pin readings.  I read that you should
  //do this but haven't tested the importance
    delay(1); 

  int y = analogRead(ypin);

  //add a small delay between pin readings.  I read that you should
  //do this but haven't tested the importance
    delay(1); 

  int z = analogRead(zpin);

  //zero_G is the reading we expect from the sensor when it detects
  //no acceleration.  Subtract this value from the sensor reading to
  //get a shifted sensor reading.
  float zero_G = 512.0; 

  //scale is the number of units we expect the sensor reading to
  //change when the acceleration along an axis changes by 1G.
  //Divide the shifted sensor reading by scale to get acceleration in Gs.
  float scale = 102.3;

  Serial.print(((float)x - zero_G)/scale);
  Serial.print("\t");

  Serial.print(((float)y - zero_G)/scale);
  Serial.print("\t");

  Serial.print(((float)z - zero_G)/scale);
  Serial.print("\n");

  // delay before next reading:
  delay(sampleDelay);
}

With this sketch, now you’ll get serial output that looks something like this:

0.00	-0.05	1.06
0.00	-0.05	1.06
-0.01	-0.05	1.06
0.00	-0.05	1.06

There is very little acceleration in the x and y directions, and about 1G of acceleration in the z direction: this is the acceleration of gravity and it is about what we expect.

Now turn it over, and you’ll see something like this:

0.02	-0.03	-0.96
0.05	-0.08	-0.96
0.05	-0.03	-0.95
0.06	-0.06	-0.95

Again there is little acceleration in the x and y directions, and about -1G in the z direction, just what we expect.

This isn’t bad, but don’t we really want to see readings like “0.00  0.00  1.00”?  The readings we are getting have magnitudes that are not equal to 1.00 and the magnitude seems to depend on the orientation of the device.  This suggests that the zero-G reading and the scale factor we got from the datasheet aren’t quite right.

It turns out we can do much better with an empirical calibration, but that is the subject of another post.

Wrap-up

Hopefully this is enough to get you up and running with the ADXL335 on the Arduino.  Now go out and make something!