sensors_mcp_hero.jpg

The MCP3008 is a low cost 8-channel 10-bit analog to digital converter.  The precision of this ADC is similar to that of an Arduino Uno, and with 8 channels you can read quite a few analog signals from the Pi.  This chip is a great option if you simply need to read simple analog signals, like from a temperature or light sensor.  If you need more precision or features, cheque out the ADS1x115 serial on the next page.

Earlier you lot use the MCP3008 information technology will help to skim this older Raspberry Pi MCP3008 guide for more than information about using it with the Raspberry Pi.  However don't utilise the code from the older guide as information technology's deprecated.  This guide will show you lot an easier way to install and utilise new Python code to talk to the MCP3008 ADC.

The MCP3008 datasheet is as well an important resource to skim and have handy.

Wiring

The MCP3008 connects to the Raspberry Pi using a SPI serial connection.  You lot tin can use either the hardware SPI bus, or whatsoever four GPIO pins and software SPI to talk to the MCP3008.  Software SPI is a little more flexible since it tin piece of work with any pins on the Pi, whereas hardware SPI is slightly faster but less flexible considering it but works with specific pins.  If y'all aren't certain which to apply I recommend software SPI as it'south easier to setup.

Earlier you can wire the fleck to the Pi you first need to place it into a breadboard.  If y'all haven't used bare DIP chips like the MCP3008 before you lot want to press it into the breadboard so its legs straddle the empty aqueduct in the middle of the breadboard.  This way you tin access each of the legs of the scrap from the breadboard.

Notation that the orientation of the chip matters!  Be sure to identify it with the half circle indention and dot towards the top.  Meet the photo below for an example:

sensors_mcp_orient.jpg

Once the fleck is in the breadboard then you're ready to connect information technology to the Pi.  Each of the legs of the MCP3008 bit have the post-obit names:

sensors_raspberry_pi_mcp3008pin.gif

Remember the orientation of the bit matters and you lot MUST have it with the one-half circumvolve indentation towards the top like the diagram higher up!

Software SPI

To connect the MCP3008 to the Raspberry Pi with a software SPI connexion you need to make the following connections:

  • MCP3008 VDD to Raspberry Pi iii.3V
  • MCP3008 VREF to Raspberry Pi 3.3V
  • MCP3008 AGND to Raspberry Pi GND
  • MCP3008 DGND to Raspberry Pi GND
  • MCP3008 CLK to Raspberry Pi pin 18
  • MCP3008 DOUT to Raspberry Pi pin 23
  • MCP3008 DIN to Raspberry Pi pin 24
  • MCP3008 CS/SHDN to Raspberry Pi pin 25

Note that you tin can swap the MCP3008 CLK, DOUT, DIN, and CS/SHDN pins to whatever other free digital GPIO pins on the Raspberry Pi.  Y'all'll just need to modify the example code to employ your pins.

Hardware SPI

To use hardware SPI beginning make sure you've enabled SPI using the raspi-config tool.  Be sure to answer yes to both enabling the SPI interface and loading the SPI kernel module, and then reboot the Pi.  Check you can encounter a /dev/spidev0.0 and /dev/spidev0.i device when you lot run the ls -l /dev/spi* command before standing.

Now wire the MCP3008 to the Raspberry Pi as follows:

  • MCP3008 VDD to Raspberry Pi 3.3V
  • MCP3008 VREF to Raspberry Pi 3.3V
  • MCP3008 AGND to Raspberry Pi GND
  • MCP3008 DGND to Raspberry Pi GND
  • MCP3008 CLK to Raspberry Pi SCLK
  • MCP3008 DOUT to Raspberry Pi MISO
  • MCP3008 DIN to Raspberry Pi MOSI
  • MCP3008 CS/SHDN to Raspberry Pi CE0

Library Install

After you've wired the MCP3008 to the Raspberry Pi with either the software or hardware SPI wiring y'all're prepare to install the Adafruit MCP3008 Python library.

Y'all tin install the library from the Python bundle index with a few commands, or you can install the library from its source on GitHub.  Pick one of these options below.  If you aren't sure I recommend installing from source on GitHub because information technology will likewise download examples to use the library.

Note that before y'all install the library your Raspberry Pi must exist continued to the net through a wired or wireless network connection.

Source Install

To install from the source on Github connect to a terminal on the Raspberry Pi and run the following commands:

sudo apt-get update sudo apt-become install build-essential python-dev python-smbus git cd ~ git clone https://github.com/adafruit/Adafruit_Python_MCP3008.git cd Adafruit_Python_MCP3008 sudo python setup.py install
sudo apt-get update sudo apt-become install build-essential python-dev python-smbus git cd ~ git clone https://github.com/adafruit/Adafruit_Python_MCP3008.git cd Adafruit_Python_MCP3008 sudo python setup.py install

You lot should meet the library install succeed and stop with a message like to the following:

sensors_Screenshot_from_2016-02-09_02_09_04.png

If y'all see an error go back and carefully check all the previous commands were run, and that they didn't fail with an error.

Python Package Alphabetize Install

To install from the Python bundle alphabetize connect to a terminal on the Raspberry Pi and execute the following commands:

sudo apt-get update sudo apt-go install build-essential python-dev python-smbus python-pip sudo pip install adafruit-mcp3008
sudo apt-get update sudo apt-get install build-essential python-dev python-smbus python-pip sudo pip install adafruit-mcp3008

You should come across a message like the following that the library was successfully installed:

sensors_Screenshot_from_2016-02-09_02_13_13.png

Note that if yous install from the Python bundle alphabetize yous won't have the instance code for the library.  You lot'll need to download these MCP3008 examples to the Pi manually and run them in the next section.

Library Usage

To learn how to use the library I'll walk through some of the case lawmaking included with information technology.  These examples are in the examples folder if you lot downloaded and installed the library from source.  Alter to that folder by running on the Pi:

cd ~/Adafruit_Python_MCP3008/examples
cd ~/Adafruit_Python_MCP3008/examples

Note: If yous installed the library from the Python bundle index using the pip control yous won't have the example code and will need to download it to the Pi manually.

Nosotros'll start by looking at the simpletest.py example which is a basic example of reading and displaying the ADC aqueduct values.  Beginning allow's open the file to configure information technology to apply software or hardware SPI.  Run the following command to open the file in the nano text editor:

nano simpletest.py
nano simpletest.py

Now scroll downwardly to the post-obit block of code near the top:

# Software SPI configuration: CLK  = 18 MISO = 23 MOSI = 24 CS   = 25 mcp = Adafruit_MCP3008.MCP3008(clk=CLK, cs=CS, miso=MISO, mosi=MOSI)  # Hardware SPI configuration: # SPI_PORT   = 0 # SPI_DEVICE = 0 # mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))
# Software SPI configuration: CLK  = 18 MISO = 23 MOSI = 24 CS   = 25 mcp = Adafruit_MCP3008.MCP3008(clk=CLK, cs=CS, miso=MISO, mosi=MOSI)  # Hardware SPI configuration: # SPI_PORT   = 0 # SPI_DEVICE = 0 # mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))

By default this section of code configures the chip to use the software SPI configuration described in the previous section.  If you used different pins for your software SPI setup be sure to change the values of CLK, MISO, MOSI, CS to the pins you used.

If yous used hardware SPI then yous'll demand to annotate out the software SPI section and uncomment the hardware SPI section.  The configuration should look like this for hardware SPI:

# Software SPI configuration: # CLK  = xviii # MISO = 23 # MOSI = 24 # CS   = 25 # mcp = Adafruit_MCP3008.MCP3008(clk=CLK, cs=CS, miso=MISO, mosi=MOSI)  # Hardware SPI configuration: SPI_PORT   = 0 SPI_DEVICE = 0 mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))
# Software SPI configuration: # CLK  = 18 # MISO = 23 # MOSI = 24 # CS   = 25 # mcp = Adafruit_MCP3008.MCP3008(clk=CLK, cs=CS, miso=MISO, mosi=MOSI)  # Hardware SPI configuration: SPI_PORT   = 0 SPI_DEVICE = 0 mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))

At present relieve the file past pressing Ctrl-o, enter, so Ctrl-x to quit.  You lot tin can run the simpletest.py code by executing at the terminal:

sudo python simpletest.py
sudo python simpletest.py

The case will print out a tabular array with all of the ADC channels and their values.  Every half second a new row volition exist printed with the latest channel values.  For example you might see output like:

sensors_Screenshot_from_2016-02-09_02_30_13.png

Each column represents a different channel and the header on the offset row shows the channel number (from 0 to seven, 8 channels full).  The value for each channel is the ADC value for that channel.  This is a number that ranges from 0 to 1023, where 0 means the signal is at a ground level, and 1023 means information technology's at the AREF value (iii.3V) or higher.  In between values are proportional to each other, so a value of 512 is most 3.3 / ii or ane.65 volts.

Press Ctrl-c to end the case.

Try connecting a potentiometer to i of the analog inputs.  Connect the middle leg of the potentiometer (the wiper) to an analog input, then connect one of the other legs to Pi iii.3V and the other leg to Pi ground.  Run the example and twist the potentiometer effectually.  You should run across the ADC value change and get lower equally the voltage from the potentiometer decreases, and get higher as the voltage increases!

To understand how the code works open up the simpletest.py example in nano again.  Now scroll downwardly to the primary loop at the bottom:

print('Reading MCP3008 values, press Ctrl-C to quit...') # Print nice aqueduct column headers. print('| {0:>4} | {1:>four} | {2:>four} | {3:>4} | {4:>4} | {five:>iv} | {6:>iv} | {7:>iv} |'.format(*range(8))) print('-' * 57) # Main programme loop. while True:     # Read all the ADC aqueduct values in a list.     values = [0]*8     for i in range(eight):         # The read_adc function will get the value of the specified channel (0-7).         values[i] = mcp.read_adc(i)     # Print the ADC values.     print('| {0:>4} | {1:>4} | {2:>4} | {3:>four} | {4:>4} | {5:>4} | {6:>4} | {vii:>4} |'.format(*values))     # Pause for one-half a second.     time.slumber(0.5)
impress('Reading MCP3008 values, press Ctrl-C to quit...') # Print nice aqueduct column headers. print('| {0:>iv} | {1:>4} | {2:>4} | {3:>4} | {4:>iv} | {five:>four} | {6:>4} | {7:>4} |'.format(*range(8))) print('-' * 57) # Main programme loop. while Truthful:     # Read all the ADC channel values in a list.     values = [0]*8     for i in range(8):         # The read_adc function volition get the value of the specified channel (0-7).         values[i] = mcp.read_adc(i)     # Print the ADC values.     print('| {0:>iv} | {one:>four} | {2:>four} | {3:>4} | {4:>4} | {five:>iv} | {half dozen:>4} | {vii:>4} |'.format(*values))     # Suspension for half a second.     time.sleep(0.5)

The code might look a trivial complicated merely almost of that complication is from printing the tabular array.  Notice this line that reads an ADC aqueduct value and saves it in a list:

values[i] = mcp.read_adc(i)

This line is calling the read_adc() part from the MCP3008 Python library.  The office takes one parameter, the channel number to read (a value of 0 to vii).  As a result the function volition return the current ADC value of that channel.

Reading an ADC aqueduct in your ain code is as piece of cake as calling the read_adc() function!  Pass in the channel to read and information technology will render the value.  That'south all in that location really is to using the MCP3008 library to read an analog value!

If you're curious yous can examine and run the differential.py instance simply like y'all ran simpletest.py.  Modify the configuration to suite your wiring, either software or hardware SPI.  Then when yous run the instance information technology volition call the read_adc_difference() part and use information technology to read the voltage difference between aqueduct 0 and 1 of the bit.  Sometimes it'due south useful to read the deviation of two signals to assistance reduce racket and other artifacts from analog signals.

That's all there is to the MCP3008 Python library!

This guide was start published on Feb 09, 2016. It was last updated on February 09, 2016.

This page (MCP3008) was final updated on Mar 03, 2022.

Text editor powered past tinymce.