Output: Converting Digital to Analog

Just as in Chapter 7, you’ll use the GPIO Python module already installed in the most recent versions of Raspbian Linux. The module has experimental functions for controlling the GPIO pins, sort of like a dimmer switch.

We say that it’s “sort of” like a dimmer switch because the module uses a method called pulse-width modulation, or PWM, to make it seem like there’s a range of voltages coming out of its outputs. What it’s actually doing is pulsing its pins on and off really quickly. So if you want the pin to behave as though it’s at half voltage, the pin will be pulsed so that it is on 50% of the time and off 50% of the time. If you want the pin to behave as though it’s at 20% power, the Raspberry Pi will turn the pin on 20% of the time and off 80% of the time. The percentage of time that it’s on versus total time of the cycle is called the duty cycle (Figure 8-2). When you connect an LED to these pins and instruct the Raspberry Pi to change the duty cycle, it has the effect of dimming the LED.

Figure 8-2. The duty cycle represents how much time the pin is turned on over the course of an on-off cycle

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
GPIO.setup(25, GPIO.OUT)

p = GPIO.PWM(25, 50) 
p.start(0) 

while True:
   for dc in range(0, 100, 5): 
      p.ChangeDutyCycle(dc) 
      time.sleep(0.05)
   for dc in range(100, 0, -5): 
      p.ChangeDutyCycle(dc)
      time.sleep(0.05)

Input: Converting Analog to Digital

Just like you controlled the output of a GPIO pin on a scale of 0 to 100, it’s also possible to read sensors that can offer the Raspberry Pi a range of values. If you want to know the temperature of a room, the light level, or the amount of pressure on a pad, you can use various sensors. On a microcontroller like the Arduino, there’s special hardware to convert the analog voltage level to digital data. Unfortunately, your Raspberry Pi doesn’t have have this hardware built in.

To convert from analog to digital, this section will show you how to use an ADC, or analog-to-digital converter. There are a few different models of ADCs out there, but this chapter will use the ADS1x15 from Texas Instruments. The package of the ADS1x15 chip is too small for your standard breadboard, so Adafruit Industries has created a breakout board for it, shown in Figure 8-3. Once you’ve soldered header pins to the breakout board, you can prototype with this chip in your breadboard. The chip uses a protocol named Inter-Integrated Circuit (commonly called I2C) for transmitting the analog readings. Luckily, we don’t need to understand the protocol in order to use it. Adafruit provides an excellent open source Python library to read the values from the ADS1115 or its little brother, the ADS1015, via I2C.

To connect the ADS1115 or ADS1015 breakout to your Raspberry Pi:

1. Connect the 3.3 volt pin from the Raspberry Pi to the positive rail of the breadboard. Refer to Figure 6-2 for pin locations on the Raspberry Pi’s GPIO header.

2. Connect the ground pin from the Raspberry Pi to the negative rail of the breadboard.

3. Insert the ADS1x15 into the breadboard and use jumper wires to connect its VDD pin to the positive rail and its GND pin to the negative rail.

4. Connect the SCL pin on the ADS1x15 to the SCL pin on the Raspberry Pi. The SCL pin on the Pi is the one paired with the ground pin on the GPIO header.

5. Connect the SDA pin on the ADS1x15 to the SDA pin on the Raspberry Pi. The SDA pin is in between the the SCL pin and the 3.3 volt pin.

Figure 8-3. The ADS1015 analog-to-digital converter breakout from Adafruit

Now you’ll need to connect an analog sensor to the ADS1x15. There are many to choose from, but for this walk-through, you’ll use a 2K potentiometer so that we can have a dial input for your Raspberry Pi. A potentiometer, or pot, is essentially a variable voltage divider, and can come in the form of a dial or slider.

To connect a potentiometer to the ADS1x15:

1. Insert the potentiometer into the breadboard.

2. The pot has three pins. Connect the middle pin to pin A0 in on the ADS1x15.

3. One of the outside pins should connect to the positive rail of the breadboard. For now, it doesn’t matter which.

4. Connect the other outside pin to the negative rail of the breadboard.

The connections should look as shown in Figure 8-4.

Figure 8-4. Using the ADS1x15 to connect a potentiometer to the Raspberry Pi

Before you can read the potentiometer, you’ll need to enable I2C and install a a few things (see Figure 8-5):

Figure 8-5. Enabling the I2C interface

1. Open up the Raspberry Pi Configuration tool by clicking on Menu→Preferences→Raspberry Pi Configuration.

2. Click the Interfaces tab.

3. Next to I2C, click Enable.

4. Click OK and reboot your Raspberry Pi.

5. Open up a Terminal window and update your list of packages:

   $ sudo apt-get update
   

6. Install i2c-tools tools:

   $ sudo apt-get install i2c-tools
   

7. Restart your Raspberry Pi.

8. After you’ve restarted your Raspberry Pi, test that the Raspberry Pi can detect the ADS1x15 with the command:

   $ sudo i2cdetect -y 1
   

9. If the board is recognized, you’ll see the number in the grid that is displayed:

        0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
   00:          -- -- -- -- -- -- -- -- -- -- -- -- --
   10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
   20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
   30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
   40: -- -- -- -- -- -- -- -- 48 -- -- -- -- -- -- --
   50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
   60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
   70: -- -- -- -- -- -- -- --
   

10. Now that we know that the device is connected and is recognized by our Pi, it’s time to start reading the potentiometer. To do so, download the Raspberry Pi Python library from Adafruit’s code repository into your home folder. Type the following command at the shell prompt, all on one line with no spaces in the URL:

    wget https://github.com/adafruit/Adafruit_Python_ADS1x15/
      archive/master.zip

11. Unzip it:

    $ unzip master.zip
    

12. Change to the library’s ADS1x15 directory:

    $ cd Adafruit_Python_ADS1x15-master/
    

13. Install the library:

    $ sudo python setup.py install/
    

14. Run one of the example files:

    $ python examples/simpletest.py
    

15. Turn the potentiometer all the way in one direction and back in the other. Notice how the value in the pin 0 column changes:

    Reading ADS1x15 values, press Ctrl-C to quit...
    |      0 |      1 |      2 |      3 |
    -------------------------------------
    |      0 |   4320 |   4496 |   4528 |
    |      0 |   4224 |   5104 |   4432 |
    |      0 |   4352 |   4688 |   5104 |
    |   6128 |   4640 |   4384 |   5552 |
    |  10928 |   4592 |   4592 |   5056 |
    |  18736 |   4384 |   4992 |   4384 |
    |  23312 |   4496 |   4912 |   4784 |
    |  26512 |   4912 |   4800 |   5968 |
    |  25968 |   4816 |   4800 |   5008 |
    |  16528 |   4416 |   4928 |   4928 |
    |   9280 |   4656 |   4416 |   5312 |
    |   2688 |   4240 |   5008 |   4464 |
    |      0 |   4384 |   4352 |   5360 |
    |      0 |   4336 |   4624 |   4272 |
    |      0 |   4256 |   4432 |   4592 |
    

16. Press Ctrl-C to terminate the script.

As you can see, turning the dial on the potentiometer changes the voltage coming into channel 0 of the ADS1x15. The code in the example does a little bit of math to determine the voltage value from the data coming from the ADC. Of course, your math will vary depending on what kind of sensor you use.

You can look inside that example script to see how it works, or try out the even simpler example that follows to learn how to take readings from the ADC. Create a new file with the code from Example 8-1 and execute it.

from Adafruit_ADS1x15 
from time import sleep

adc = Adafruit_ADS1x15.ADS1115() 

while True:
   result = adc.read_adc(0) 
   print result
   sleep(.5)

Import Adafruit’s ADS1x15 library.

Create a new ADS1x15 object called adc.

Get a reading from channel A0 on the ADS1x15 and store it in result.

When you run this code, it will output out raw numbers for each reading twice a second. Turning the potentiometer will make the values go up or down.

Once you get it all set up, the Adafruit ADS1x15 library does all the hard work for you and makes it easy to use analog sensors in your projects. For instance, if you want to make your own Pong-like game, you could read two potentiometers and then use Pygame to draw on the game on screen. For more information about using Pygame, see Chapter 4.

Variable Resistors

Not all analog sensors work like the potentiometer, which provides a variable voltage based on some factor (such as the amount the dial on the pot is turned).

Some sensors are simply variable resistors that resist the flow of electricity based on some factor. For instance, a photocell like the one in Figure 8-6 will act like a resistor that changes values based on the amount of light hitting the cell. Add more light, and the resistance goes down. Take away light, and the resistance goes up. A force-sensitive resistor decreases its resistance as you put pressure on the pad.

Figure 8-6. The photocell and force-sensitive resistors act as variable resistors and can be used as analog inputs

In order to read sensors like these with analog input pins, you’ll need to incorporate a voltage divider circuit.

Voltage Divider Circuit

When you’re working with sensors that offer variable resistance, the purpose of a voltage divider is to convert the variable resistance into a variable voltage, which is what the analog input pins are measuring. First, take a look at a simple voltage divider.

In Figure 8-7, you’ll see two resistors of the same value in series between the positive and ground and one wire connected to analog input 0 between the two resistors. Because both resistors are 10K ohms, there’s about 1.65 volts going to analog input 0, half of 3.3 volts.

Figure 8-7. With two of the same value resistors between voltage and ground, the voltage between the two would be half of the total voltage

Without getting bogged down in the math involved, if you removed the 10K resistor connected to 3.3 volts and replaced it with a resistor of a higher value, the voltage going into the analog pin would decrease. If you removed that 10K resistor and replaced it with one of a lower value, the voltage going into the analog pin would increase. We can use this principle with sensors that are variable resistors in order to read them with the analog input pins. You’ll simply replace one of the resistors with your sensor.

To try the circuit out, you’ll have to wire up a type of variable resistor called a force-sensitive resistor, or FSR.

Force-Sensitive Resistor

A force-sensitive resistor is a variable resistor that changes based on the amount of pressure placed on its pad. When there’s no pressure on the pad, the circuit is open. When you start placing pressure on it, the resistance drops.

The exact figures will depend on your particular FSR, but typically you’ll see 100K ohms of resistance with light pressure and 1 ohm of resistance with maximum pressure. If you have a multimeter, you can measure the changes in resistance to see for yourself, or you can look at the component’s datasheet, which will tell you what to expect from the sensor.

If you’re going to replace the resistor connected to 3.3 volts in Figure 8-7 with a variable resistor like an FSR, you’ll want the value of the other resistor to be somewhere in between the minimum and maximum resistance so that you can get the most range out of the sensor. For a typical FSR, try a 10K ohm resistor. To give the force-sensitive resistor a test drive:

1. Wire up an FSR to the ADC as shown in Figure 8-8.

2. Execute the code in Example 8-1 again.

3. Watch the readings on the screen as you squeeze the FSR.

If everything is working correctly, you should see the values rise as you increasingly squeeze harder on the FSR. As you press harder, you’re reducing the resistance between the two leads on the FSR. This has the effect of sending higher voltage to the analog input.

You’ll encounter many analog sensors that use this very same principle, and a simple voltage divider circuit, along with an analog-to-digital converter, will allow your Raspberry Pi to capture that sensor data.

Figure 8-8. Wiring up a force-sensitive resistor to the ADC requires a voltage divider circuit

Going Further

Controlling a DC Motor with PWM

Adafruit has an excellent guide that teaches you how to use PWM to control the speed of a DC motor.

Reading Resistive Sensors with RC Timing

Adafruit also shows you how to use a simple circuit to read resistive analog sensors without an analog-to-digital converter.