Arduino: A Quick-Start Guide, Second Edition (2015)

Part II. Eleven Arduino Projects

Chapter 6. Building a Motion-Sensing Game Controller

It’s astonishing how quickly we get used to new technologies. A decade ago, not many people would’ve imagined that we would use devices someday to follow our movements. Today, it’s absolutely normal for us to physically turn our smartphones when we want to change from portrait to landscape view. Even small children intuitively know how to use motion-sensing controllers for video game consoles, such as Nintendo’s Wii. You can build your own motion-sensing devices using an Arduino, and in this chapter you’ll learn how.

We’ll work with one of the most widespread motion-sensing devices: the accelerometer. Accelerometers detect movement in all directions—they notice if you move them up or down (Z-axis), forward or backward (Y-axis), and to the left or to the right (X-axis). Many popular gadgets, such as the iPhone and the Nintendo Wii controllers, contain accelerometers, so accelerometers are produced in large quantities. That’s why they’re cheap.

Both fun and serious projects can benefit from accelerometers. When working with your computer, you certainly think of devices, such as game controllers or other input control devices, that you connect via USB. But you can also use them when exercising or to control a real-life marble maze. They are also the right tool for measuring acceleration indirectly, such as in a car.

You will learn how to interpret accelerometer data correctly and how to get the most accurate results. Then you’ll use an accelerometer to build a motion-sensing game controller, and in the next chapter you’ll implement a game that uses it.

What You Need

1. An Arduino Proto Shield (optional)

2. An ADXL335 accelerometer

3. A pushbutton

4. A 10kΩ resistor

5. Some wires

6. A half-size breadboard (if you’re not using a Proto Shield)

7. An Arduino board, such as the Uno, Duemilanove, or Diecimila

8. A USB cable to connect the Arduino to your computer

9. A 6-pin 0.1-inch standard header

Wiring Up the Accelerometer

There are many different accelerometers, differing mainly in the number of spatial axes they support (usually two or three). I’ll use the ADXL335 from Analog Devices—it’s easy to use and widely available.^[62] Analog Devices offers many more accelerometers, named ADXL345, ADXL377, or ADXL326, for example. They all work the same, and they differ only in accuracy and price.

In this section, we’ll connect the ADXL335 to the Arduino and create a small demo program showing the raw data the sensor delivers. At that point, we will have a quick look at the sensor’s specification and interpret the data.

This picture shows a breakout board containing an ADXL335 sensor on the right. The sensor is the small black integrated circuit (IC), and the rest is just a carrier to allow connections. On the top, you see a 6-pin 0.1-inch standard header. The sensor has six connectors, labeled GND, Z, Y, X, VCC, and ST. To use the sensor on a breadboard, solder the standard header to the connectors. This not only makes it easier to attach the sensor to a breadboard, but it also stabilizes the sensor so it doesn’t move accidentally. You can see the result on the left side of the photo. (Note that the breakout board on the left isn’t the same as on the right, but it’s very similar.) Don’t worry if you’ve never soldered before. In Learning How to Solder, you can learn how to do it.

You can ignore the connector labeled ST, and the meaning of the remaining connectors should be obvious. To power the sensor, connect GND to the Arduino’s ground pin and VCC to the Arduino’s 3.3V power supply. X, Y, and Z will then deliver acceleration data for the x-, y-, and z-axes.

Note that not all breakout boards have the same connectors. Usually, they have six or seven connectors. Some breakout boards can cope with 5V, while others only work with 3.3V. Some boards have an input pin named VIN that you have to connect to one of the Arduino’s power supply pins (5V or 3.3V).

Like the TMP36 temperature sensor we used in Increasing Precision Using a Temperature Sensor, the ADXL335 is an analog device: it delivers results as voltages that have to be converted into acceleration values. So, the X, Y, and Z connectors have to be connected to three analog pins on the Arduino. We connect Z to analog pin 0, Y to analog pin 1, and X to analog pin 2. (See the following image and double-check the pin labels on the breakout board you’re using!) Naturally, you’ll move around the accelerometer a lot, so it’s best to use long wires.

Now that we’ve connected the ADXL335 to the Arduino, let’s use it.

Bringing Your Accelerometer to Life

A pragmatic strategy to get familiar with a new device is to hook it up and see what data it delivers. The following program reads input values for all three axes and outputs them to the serial port:

Our test program is as simple as it can be. We define constants for the three analog pins and initialize the serial port in the setup function. Note that we didn’t set the analog pins to INPUT explicitly, because that’s the default anyway.

In the loop function, we constantly output the values we read from the analog pins to the serial port. Open the serial monitor and move the sensor around —tilt it around the different axes. You should see output like this:

These values represent the data we get for the x-, y-, and z-axes. When you move the sensor only around the x-axis, for example, you can see that the first value changes accordingly. In the next section, we’ll take a closer look at these values.

Finding and Polishing Edge Values

The physical world often is far from perfect. That’s especially true for the data many sensors emit, and accelerometers are no exception. They vary slightly in the minimum and maximum values they generate, and they often jitter. They might change their output values even though you haven’t moved them, or they might not change their output values correctly. In this section, we’ll determine the sensor’s minimum and maximum values, and we’ll flatten the jitter.

Finding the edge values of the sensor is easy, but it cannot be easily automated. You have to constantly read the sensor’s output while moving it. Here’s a program that does the job:

We declare variables for the minimum and maximum values of all three axes, and we initialize them with numbers that are definitely out of the sensor’s range (-1000 and 1000). In the loop function, we permanently measure the acceleration of all three axes and adjust the minimum and maximum values accordingly.

Compile and upload the sketch, then move the breadboard with the sensor in all directions, and then tilt it around all axes. Move it slowly, move it fast, tilt it slowly, and tilt it fast. Be careful when moving and rotating the breadboard that you don’t accidentally loosen a connection.

After a short while, the minimum and maximum values will stabilize, and you should get output like this:

Write down these values, because we’ll need them later, and you’ll probably need them when you do your own sensor experiments.

Now let’s see how to get rid of the jitter. In principle, it’s simple. Instead of returning the acceleration data immediately, we collect the last readings and return their average. This way, small changes will be ironed out. The code looks as follows:

As usual, we define some constants for the pins we use first. This time, we also define a constant named NUM_AXES that contains the number of axes we are measuring. We also have an array named PINS that contains a list of the pins we use. This will help us keep our code more generic later.

In line 10, we declare buffers for all axes. They will be filled with the sensor data we measure, so we can calculate average values when we need them. We have to store our current position in each buffer, so in line 11, we define an array of buffer positions.

setup only initializes the serial port; the real action takes place in get_axis.

It starts with a small delay to give the Arduino some time to switch between analog pins; otherwise, you might get bad data. Then it reads the acceleration for the axis we have passed and stores it at the current buffer position belonging to the axis. It increases the buffer position and sets it back to zero when the end of the buffer has been reached. Finally, we return the average value of the data we have gathered so far for the current axis.

That’s the whole trick, and the data structure we’ve just built is named circular buffer.^[63] To see its effect, leave the sensor untouched on your desk and run the program with different buffer sizes. If you don’t touch the sensor, you wouldn’t expect the program’s output to change. But if you setBUFFER_SIZE to 1, you will quickly see small changes. They will disappear as soon as the buffer is big enough.

The acceleration data we measure now is accurate enough that we can finally build a game controller that won’t annoy users with unexpected movements.

Building Your Own Game Controller

To build a full-blown game controller, we only need to add a button to our breadboard. Figure 19, Game controller with accelerometer and pushbutton shows you how to do it. (Please double-check the pin labels on your breakout board!)