Your Smart IOT

<div class="section tutorial-page">
<p>There are many peripherals that can be added to a microprocessor over the I2C and SPI serial interfaces. These include <a href="http://bit.ly/1r9FUVK" target="_blank">atmospheric sensors</a>, <a href="http://bit.ly/24g3KAX" target="_blank">EEPROMS</a>, and <a href="http://bit.ly/1r9FWwS" target="_blank">several</a> <a href="http://bit.ly/24g3KB2" target="_blank">types</a> of <a href="http://bit.ly/1r9FWwT" target="_blank">display</a>.</p>
<p><a href="http://bit.ly/24g3KB3" target="_blank"><img alt="alt text" src="http://bit.ly/1r9FXRb" /></a></p>
<p><em>The Pi Wedge helps access the I2C and SPI signals.</em></p>
<p>This tutorial will walk you through getting the I2C and SPI interfaces of your <a href="http://bit.ly/26nCm2K" itemprop="url" target="_bank" title="Raspberry"><strong>Raspberry</strong></a> Pi working. These interfaces aren’t enabled by default, and need some extra configuration before you can use them.</p>
<h3>Recommended Reading</h3>
<p>Before we get started, you might want to review some related background material.</p>
<ul>
<li><a href="http://bit.ly/1r9FXRc" target="_blank">I2C</a> is a useful bus that allows data exchange between microcontrollers and peripherals with a minimum of wiring.</li>
<li><a href="http://bit.ly/24g3IJv" target="_blank">SPI</a> is a cousin of I2C with similar applications.</li>
<li>We’ll be using the <a href="http://wiringpi.com/" target="_blank">wiringPi</a> library to interface with these buses.</li>
</ul>
</div>
<div class="section tutorial-page">
<h2 id="background--software-setup">Background & Software Setup</h2>
<p>The <a href="http://bit.ly/1T5ac2c" itemprop="url" target="_bank" title="Raspberry"><strong>Raspberry</strong></a> Pi has three types of serial interface on the GPIO header. You’re probably already familiar with the UART serial port, which allows you to open a login session from a serial terminal application, such as <a href="http://bit.ly/24g3IJw" target="_blank">PuTTY</a>.</p>
<p>The other two serial interfaces are the Serial Peripheral Interface (SPI) and Inter-Integrated-Circuit bus (I2C).  <a href="http://bit.ly/24g3IJv" target="_blank">SPI</a> on the Pi allows for up to two attached devices, while <a href="http://bit.ly/1r9FXRc" target="_blank">I2C</a> potentially allows for many devices, as long as their addresses don’t conflict.</p>
<h3>Software Details</h3>
<p>The software landscape for the Raspberry Pi has evolved considerably since the introduction of the Pi. Many different operating systems have been ported to the Pi, and the device driver infrastructure has also changed quite a bit.</p>
<p>For this tutorial, we’ll be using a recent version of <a href="http://bit.ly/1r9FWNe" itemprop="url" target="_bank" title="Raspbian"><strong>Raspbian</strong></a> (installed via NOOBS), and the wiringPi I/O library.</p>
<p>With the implementation of device tree overlays in <a href="http://bit.ly/24g3KRq" itemprop="url" target="_bank" title="Raspbian"><strong>Raspbian</strong></a>, some of the specific interface enablement details have changed. If you’re working with an older install, it might be worth backing up your SD card, and starting with a fresh install.</p>
<h4>OS and Library Install</h4>
<p>If you’re starting from scratch, with a blank SD card, you’ll want to install Raspbian. If you’ve already got a working Raspbian system, skip ahead to step 3.</p>
<ol>
<li>Download the <a href="http://bit.ly/1r9FWNf" target="_blank">NOOBS</a> image. As of this writing, it’s at version 1.4.2.</li>
<li>Follow the official <a href="http://bit.ly/24g3KRt" target="_blank">installation instructions</a>.</li>
<li>Follow the <a href="http://bit.ly/1r9FWNg" target="_blank">Wiring Pi Instructions</a> to get <em>git</em>, update and upgrade your Rasbpian packages, then install WwiringPi.</li>
</ol>
<p>Be patient – each of these steps takes a while.</p>
<p>Once you’ve got wiringPi installed, run the <code>gpio</code> commands shown below.</p>
<div class="copy-code" data-code-id="code-0"><button class="btn btn-default btn-sm">COPY CODE</button></div>
<pre>
<code>>gpio -v
>gpio readall
</code>
</pre>
<p>It should respond with some information about the wiringPi version and the Pi that its running on, then draw a table illustrating the configuration for the pins in the 40-pin connector.</p>
<p>The I2C and SPI interfaces each require some additional configuration and initialization, which we’ll cover in later sections.</p>
</div>
<div class="section tutorial-page">
<h2 id="connecting-to-the-ports">Connecting To The Ports</h2>
<p>Before we get into the configuration and software examples, lets locate the pins used by each of these interfaces.</p>
<p>If you’re directly connecting to the pins on the Pi, they’re a little disorganized. I2C.1 is near one end, while SPI and I2C.0 are in the middle of the header. If you’re connecting to these pins, be sure to count carefully.</p>
<p><a href="http://bit.ly/24g3KRv" target="_blank"><img alt="alt text" src="http://bit.ly/24g3KRv" /></a></p>
<p><em>Pi Serial Bus Pins</em></p>
<p>The <a href="http://bit.ly/1r9FXRj" target="_blank">Pi Wedge</a> adapter PCB rearranges the pins, and labels them clearly. We’ll be using the Wedge for the following examples.</p>
<p><a href="http://bit.ly/24g3IZO" target="_blank"><img alt="alt text" src="http://bit.ly/1r9FWNl" /></a></p>
<p><em>Wedge Serial Bus Pins</em></p>
</div>
<div class="section tutorial-page">
<h2 id="spi-on-pi">SPI on Pi</h2>
<h3>Configuration</h3>
<p>The SPI peripheral is not turned on by default. To enable it, do the following.</p>
<ol>
<li>Run <code>sudo raspi-config</code>.</li>
<li>Use the down arrow to select <code>9 Advanced Options</code></li>
<li>Arrow down to <code>A6 SPI</code>.</li>
<li>Select <code>yes</code> when it asks you to enable SPI,</li>
<li>Also select <code>yes</code> when it asks about <a href="http://bit.ly/26nCuzb" itemprop="url" target="_bank" title="How to automatically water your plants with the Raspberry Pi"><strong>automatically</strong></a> loading the kernel module.</li>
<li>Use the right arrow to select the <code><Finish></code> button.</li>
<li>Select <code>yes</code> when it asks to reboot.</li>
</ol>
<p><a href="http://bit.ly/1r9FXRn" target="_blank"><img alt="alt text" src="http://bit.ly/1r9FXRn" /></a></p>
<p><em>Raspi-config for SPI</em></p>
<p>The system will reboot. When it comes back up, log in and enter the following command</p>
<div class="copy-code" data-code-id="code-1"><button class="btn btn-default btn-sm">COPY CODE</button></div>
<pre>
<code>>ls /dev/*spi*
</code>
</pre>
<p>The Pi should respond with</p>
<div class="copy-code" data-code-id="code-2"><button class="btn btn-default btn-sm">COPY CODE</button></div>
<pre>
<code>/dev/spidev0.0  /dev/spidev0.1
</code>
</pre>
<p>These represent SPI devices on chip enable pins 0 and 1, respectively. These pins are hardwired within the Pi. Ordinarily, this means the interface supports at most two peripherals, but there are cases where multiple devices can be daisy-chained, sharing a single chip enable signal.</p>
<h3>Programming Example</h3>
<h4>Required Materials</h4>
<ul>
<li>The <a href="http://bit.ly/1r9FXRj" target="_blank">40-pin Pi Wedge</a>.</li>
<li>A <a href="http://bit.ly/24g3KRD" target="_blank">Raspberry Pi B+</a> or <a href="http://bit.ly/1r9FWNp" target="_blank">Pi 2 Model B</a> single board computer.</li>
<li>A <a href="http://bit.ly/24g3KRI" target="_blank">Solderless</a><a href="http://bit.ly/1r9FX3C" target="_blank">Breadboard</a>.</li>
<li>Some <a href="http://bit.ly/24g3L7Y" target="_blank">jumper wires</a>.</li>
<li>A <a href="http://bit.ly/1r9FWwS" target="_blank">Serial 7-Segment</a> display.</li>
</ul>
<p>The Serial 7-Segment display is particularly useful for testing serial interfaces, because it can accept command from a UART, SPI, or I2C.</p>
<h4>Connections</h4>
<p>The display was connected to the Pi, via the Pi Wedge, as follows.</p>
<table border="1" width="500" align="center">
<tbody>
<tr align="center">
<td>Rabpberry Pi Signal</td>
<td>Serial 7-seg Signal</td>
</tr>
<tr align="center">
<td>GND</td>
<td>GND</td>
</tr>
<tr align="center">
<td>3.3V</td>
<td>VCC</td>
</tr>
<tr align="center">
<td>CE1</td>
<td>SS (Shift Select)</td>
</tr>
<tr align="center">
<td>SCK</td>
<td>SCK</td>
</tr>
<tr align="center">
<td>MOSI</td>
<td>SDI</td>
</tr>
<tr align="center">
<td>MISO</td>
<td>SDO</td>
</tr>
</tbody>
</table>
<p>The test hardware looked like this.</p>
<p><a href="http://bit.ly/1r9FY7K" target="_blank"><img alt="alt text" src="http://bit.ly/24g3IZZ" /></a></p>
<p><em>Serial 7-Segment connections for SPI</em></p>
</div>
<blockquote>
<pre data-language="language:c ,c">
<code class="rainbow"><span class="comment">/******************************************************************************
i2ctest.cpp
Raspberry Pi I2C interface demo
Byron Jacquot @ SparkFun Electronics>
4/2/2014
http://bit.ly/1r9FY7L

A brief demonstration of the Raspberry Pi I2C interface, using the SparkFun
Pi Wedge breakout board.

Resources:

This example makes use of the Wiring Pi library, which streamlines the interface
to the the I/O pins on the Raspberry Pi, providing an API that is similar to the
Arduino.  You can learn about installing Wiring Pi here:
http://bit.ly/1r9FWNg

The wiringPi SPI API is documented here:
http://bit.ly/24g3J02

The init call returns a standard file descriptor.  More detailed configuration
of the interface can be performed using ioctl calls on that descriptor.
See the wiringPi SPI implementation (wiringPi/wiringPiSPI.c) for some examples.
Parameters configurable with ioctl are documented here:
http://bit.ly/1r9FY7O

Hardware connections:

This file interfaces with the SparkFun Serial 7 Segment display:
http://bit.ly/24g3J04

The board was connected as follows:
(Raspberry Pi)(Serial 7 Segment)
GND  -> GND
3.3V -> Vcc
CE1  -> SS (Shift Select)
SCK  -> SCK 
MOSI -> SDI
MISO -> SDO

To build this file, I use the command:
>  g++ spitest.cpp -lwiringPi

Then to run it, first the spi kernel module needs to be loaded.  This can be 
done using the GPIO utility.
> gpio load spi
> ./a.out

This test uses the single-segment mode of the 7 segment display.  It shifts a 
bit through the display characters, lighting a single character of each at a 
time.

Development environment specifics:
Tested on Raspberry Pi V2 hardware, running Raspbian.
Building with GCC 4.6.3 (Debian 4.6.3-14+rpi1)

This code is beerware; if you see me (or any other SparkFun employee) at the
local, and you've found our code helpful, please buy us a round!

Distributed as-is; no warranty is given.
******************************************************************************/</span>

<span class="comment">#include <iostream></span>
<span class="comment">#include <errno.h></span>
<span class="comment">#include <wiringPiSPI.h></span>
<span class="comment">#include <unistd.h></span>

using namespace std;

<span class="comment">// channel is the wiringPi name for the chip select (or chip enable) pin.</span>
<span class="comment">// Set this to 0 or 1, depending on how it's connected.</span>
<span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">int</span> CHANNEL <span class="keyword operator">=</span> <span class="constant numeric">1</span>;

<span class="keyword">int</span> <span class="function call">main</span>()
{
   <span class="keyword">int</span> fd, result;
   <span class="keyword">unsigned</span> <span class="keyword">char</span> buffer[<span class="constant numeric">100</span>];

cout <span class="keyword operator"><</span><span class="keyword operator"><</span> <span class="string">"Initializing"</span> <span class="keyword operator"><</span><span class="keyword operator"><</span> endl ;

<span class="comment">// Configure the interface.</span>
   <span class="comment">// CHANNEL insicates chip select,</span>
   <span class="comment">// 500000 indicates bus speed.</span>
   fd <span class="keyword operator">=</span> <span class="function call">wiringPiSPISetup</span>(CHANNEL, <span class="constant numeric">500000</span>);

cout <span class="keyword operator"><</span><span class="keyword operator"><</span> <span class="string">"Init result: "</span> <span class="keyword operator"><</span><span class="keyword operator"><</span> fd <span class="keyword operator"><</span><span class="keyword operator"><</span> endl;

<span class="comment">// clear display</span>
   buffer[<span class="constant numeric">0</span>] <span class="keyword operator">=</span> <span class="constant numeric">0x76</span>;
   <span class="function call">wiringPiSPIDataRW</span>(CHANNEL, buffer, <span class="constant numeric">1</span>);

<span class="function call">sleep</span>(<span class="constant numeric">5</span>);

<span class="comment">// Do a one-hot bit selection for each field of the display</span>
   <span class="comment">// It displays gibberish, but tells us that we're correctly addressing all </span>
   <span class="comment">// of the segments.</span>
   <span class="keyword">for</span>(<span class="keyword">int</span> i <span class="keyword operator">=</span> <span class="constant numeric">1</span>; i <span class="keyword operator"><</span><span class="keyword operator">=</span> <span class="constant numeric">0x7f</span>; i <span class="keyword operator"><</span><span class="keyword operator"><</span><span class="keyword operator">=</span> <span class="constant numeric">1</span>)
   {
      <span class="comment">// the decimals, colon and apostrophe dots</span>
      buffer[<span class="constant numeric">0</span>] <span class="keyword operator">=</span> <span class="constant numeric">0x77</span>;
      buffer[<span class="constant numeric">1</span>] <span class="keyword operator">=</span> i;
      result <span class="keyword operator">=</span> <span class="function call">wiringPiSPIDataRW</span>(CHANNEL, buffer, <span class="constant numeric">2</span>);

<span class="comment">// The first character</span>
      buffer[<span class="constant numeric">0</span>] <span class="keyword operator">=</span> <span class="constant numeric">0x7b</span>;
      buffer[<span class="constant numeric">1</span>] <span class="keyword operator">=</span> i;
      result <span class="keyword operator">=</span> <span class="function call">wiringPiSPIDataRW</span>(CHANNEL, buffer, <span class="constant numeric">2</span>);

<span class="comment">// The second character</span>
      buffer[<span class="constant numeric">0</span>] <span class="keyword operator">=</span> <span class="constant numeric">0x7c</span>;
      buffer[<span class="constant numeric">1</span>] <span class="keyword operator">=</span> i;
      result <span class="keyword operator">=</span> <span class="function call">wiringPiSPIDataRW</span>(CHANNEL, buffer, <span class="constant numeric">2</span>);

<span class="comment">// The third character</span>
      buffer[<span class="constant numeric">0</span>] <span class="keyword operator">=</span> <span class="constant numeric">0x7d</span>;
      buffer[<span class="constant numeric">1</span>] <span class="keyword operator">=</span> i;
      result <span class="keyword operator">=</span> <span class="function call">wiringPiSPIDataRW</span>(CHANNEL, buffer, <span class="constant numeric">2</span>);

<span class="comment">// The last character</span>
      buffer[<span class="constant numeric">0</span>] <span class="keyword operator">=</span> <span class="constant numeric">0x7e</span>;
      buffer[<span class="constant numeric">1</span>] <span class="keyword operator">=</span> i;
      result <span class="keyword operator">=</span> <span class="function call">wiringPiSPIDataRW</span>(CHANNEL, buffer, <span class="constant numeric">2</span>);

<span class="comment">// Pause so we can see them</span>
      <span class="function call">sleep</span>(<span class="constant numeric">5</span>);
   }

<span class="comment">// clear display again</span>
   buffer[<span class="constant numeric">0</span>] <span class="keyword operator">=</span> <span class="constant numeric">0x76</span>;
   <span class="function call">wiringPiSPIDataRW</span>(CHANNEL, buffer, <span class="constant numeric">1</span>);

}</code>
</pre></blockquote>
<p> </p>
<p>When you built wiringPi, you might have noticed the statement about how to compile applications against it.</p>
<blockquote>
<pre>
<code>NOTE: To compile programs with wiringPi, you need to add:
    -lwiringPi
to your compile line(s) To use the Gertboard, MaxDetect, etc.
code (the devLib), you need to also add:
    -lwiringPiDev
to your compile line(s).</code>
</pre></blockquote>
<p>Thus, we compile using the command.</p>
<blockquote>
<pre>
<code>>g++ spitest.cpp -lwiringPi -o spitest</code>
</pre></blockquote>
<div class="section tutorial-page">
<p>Which generates an executable <code>spitest</code>. When we run <code>./spitest</code>, it will exercise each of the segments of the display. It illuminates a segment in each digit for 5 seconds, before moving to the next segment. It takes about 40 seconds overall.</p>
</div>
<div class="section tutorial-page">
<h2 id="i2c-on-pi">I2C on Pi</h2>
<h3>Configuration</h3>
<p>Like the SPI peripheral, I2C is not turned on by default. Again, we can use <code>raspi-config</code> to enable it.</p>
<ol>
<li>Run <code>sudo raspi-config</code>.</li>
<li>Use the down arrow to select <code>9 Advanced Options</code></li>
<li>Arrow down to <code>A7 I2C</code>.</li>
<li>Select <code>yes</code> when it asks you to enable I2C</li>
<li>Also select <code>yes</code> when it tasks about <a href="http://bit.ly/1VNpRtY" itemprop="url" target="_bank" title="Automatically watering your plants with sensors, a Pi and webhooks"><strong>automatically</strong></a> loading the kernel module.</li>
<li>Use the right arrow to select the <code><Finish></code> button.</li>
<li>Select <code>yes</code> when it asks to reboot.</li>
</ol>
<p><a href="http://bit.ly/24g3J05" target="_blank"><img alt="alt text" src="http://bit.ly/24g3J05" /></a></p>
<p><em>Raspi-config for I2C</em></p>
<p>The system will reboot. when it comes back up, log in and enter the following command</p>
<div class="copy-code" data-code-id="code-6"><button class="btn btn-default btn-sm">COPY CODE</button></div>
<pre>
<code>>ls /dev/*i2c*
</code>
</pre>
<p>The Pi should respond with</p>
<p>/dev/i2c-1</p>
<p>Which represents the user-mode I2C interface.</p>
<h3>Utilities</h3>
<p>There is a set of command-line utility programs that can help get an I2C interface working. You can get them with the apt package manager.</p>
<div class="copy-code" data-code-id="code-7"><button class="btn btn-default btn-sm">COPY CODE</button></div>
<div class="ezAdsense adsense adsense-midtext" style="text-align:center;margin:12px;"><script async="" src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js" type="text/javascript">
</script> <ins class="adsbygoogle" style="display:block" data-ad-client="ca-pub-2979805726071943" data-ad-slot="7471922310" data-ad-format="auto"></ins> <script type="text/javascript">
//<![CDATA[
(adsbygoogle = window.adsbygoogle || []).push({});
//]]>
</script></div>
<pre>
<code>sudo apt-get install -y i2c-tools
</code>
</pre>
<p>In particular, the <code>i2cdetect</code> program will probe all the addresses on a bus, and report whether any devices are present.</p>
<div class="copy-code" data-code-id="code-8"><button class="btn btn-default btn-sm">COPY CODE</button></div>
<pre>
<code>pi@raspberrypi:~/$ i2cdetect -y 1
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: 60 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</code>
</pre>
<p>This map indicates that there is a preipheral at address 0x60. We can try to read and write its registers using the <code>i2cget</code>, <code>i2cset</code> and <code>i2cdump</code> commands.</p>
<h3>Programming Example</h3>
<h4>Required Materials</h4>
<ul>
<li>The <a href="http://bit.ly/1r9FXRj" target="_blank">40-pin Pi Wedge</a>.</li>
<li>A <a href="http://bit.ly/24g3KRD" target="_blank">Raspberry Pi B+</a> or <a href="http://bit.ly/1r9FWNp" target="_blank">Pi 2 Model B</a> single board computer.</li>
<li>A <a href="http://bit.ly/24g3KRI" target="_blank">Solderless</a> <a href="http://bit.ly/1r9FX3C" target="_blank">Breadboard</a>.</li>
<li>Some <a href="http://bit.ly/24g3L7Y" target="_blank">jumper wires</a>.</li>
<li>An <a href="http://bit.ly/1r9FX3N" target="_blank">MCP4725</a> digital-to-analog converter.</li>
</ul>
<h4>Connections</h4>
<p>The display was connected to the Pi, via the Pi Wedge, as follows.</p>
<table border="1" width="500" align="center">
<tbody>
<tr align="center">
<td>Rabpberry Pi Signal</td>
<td>MCP4725</td>
</tr>
<tr align="center">
<td>GND</td>
<td>GND</td>
</tr>
<tr align="center">
<td>3.3V</td>
<td>VCC</td>
</tr>
<tr align="center">
<td>SCL</td>
<td>SCL</td>
</tr>
<tr align="center">
<td>SDA</td>
<td>SDA</td>
</tr>
</tbody>
</table>
<p>The test hardware looked like this.</p>
<p><a href="http://bit.ly/24g3L85" target="_blank"><img alt="alt text" src="http://bit.ly/1r9FXRm" /></a></p>
<p><em>ADC on a Breadboard</em></p>
<h4>Example Program</h4>
<p>The following code writes successive values to the DAC, producing an sawtooth wave at its output pin.</p>
<div class="copy-code" data-code-id="code-9"><button class="btn btn-default btn-sm">COPY CODE</button></div>
<pre data-language="language:c ,c">
<code class="rainbow"><span class="comment">/******************************************************************************
i2ctest.cpp
Raspberry Pi I2C interface demo
Byron Jacquot @ SparkFun Electronics>
4/2/2014
http://bit.ly/1r9FY7L

A brief demonstration of the Raspberry Pi I2C interface, using the SparkFun
Pi Wedge breakout board.

Resources:

This example makes use of the Wiring Pi library, which streamlines the interface
the the I/O pins on the Raspberry Pi, providing an API that is similar to the
Arduino.  You can learn about installing Wiring Pi here:
http://bit.ly/1r9FWNg

The I2C API is documented here:
http://bit.ly/24g3J06

The init call returns a standard file descriptor.  More detailed configuration
of the interface can be performed using ioctl calls on that descriptor.
See the wiringPi I2C implementation (wiringPi/wiringPiI2C.c) for some examples.
Parameters configurable with ioctl are documented here:
http://bit.ly/1r9FX3P

Hardware connections:

This file interfaces with the SparkFun MCP4725 breakout board:
http://bit.ly/24g3Jgl

The board was connected as follows:
(Raspberry Pi)(MCP4725)
GND  -> GND
3.3V -> Vcc
SCL  -> SCL
SDA  -> SDA

An oscilloscope probe was connected to the analog output pin of the MCP4725.

To build this file, I use the command:
>  g++ i2ctest.cpp -lwiringPi

Then to run it, first the I2C kernel module needs to be loaded.  This can be 
done using the GPIO utility.
> gpio load i2c 400
> ./a.out

This will run the MCP through its output range several times.  A rising 
sawtooth will be seen on the analog output.

Development environment specifics:
Tested on Raspberry Pi V2 hardware, running Raspbian.
Building with GCC 4.6.3 (Debian 4.6.3-14+rpi1)

This code is beerware; if you see me (or any other SparkFun employee) at the
local, and you've found our code helpful, please buy us a round!

Distributed as-is; no warranty is given.
******************************************************************************/</span>

<span class="comment">#include <iostream></span>
<span class="comment">#include <errno.h></span>
<span class="comment">#include <wiringPiI2C.h></span>

using namespace std;

<span class="keyword">int</span> <span class="function call">main</span>()
{
   <span class="keyword">int</span> fd, result;

<span class="comment">// Initialize the interface by giving it an external device ID.</span>
   <span class="comment">// The MCP4725 defaults to address 0x60.   </span>
   <span class="comment">//</span>
   <span class="comment">// It returns a standard file descriptor.</span>
   <span class="comment">// </span>
   fd <span class="keyword operator">=</span> <span class="function call">wiringPiI2CSetup</span>(<span class="constant numeric">0x60</span>);

cout <span class="keyword operator"><</span><span class="keyword operator"><</span> <span class="string">"Init result: "</span><span class="keyword operator"><</span><span class="keyword operator"><</span> fd <span class="keyword operator"><</span><span class="keyword operator"><</span> endl;

<span class="keyword">for</span>(<span class="keyword">int</span> i <span class="keyword operator">=</span> <span class="constant numeric">0</span>; i <span class="keyword operator"><</span> <span class="constant numeric">0x0000ffff</span>; i<span class="keyword operator">+</span><span class="keyword operator">+</span>)
   {
      <span class="comment">// I tried using the "fast write" command, but couldn't get it to work.  </span>
      <span class="comment">// It's not entirely obvious what's happening behind the scenes as</span>
      <span class="comment">// regards to endianness or length of data sent.  I think it's only </span>
      <span class="comment">// sending one byte, when we really need two.</span>
      <span class="comment">//</span>
      <span class="comment">// So instead I'm doing a 16 bit register access.  It appears to </span>
      <span class="comment">// properly handle the endianness, and the length is specified by the </span>
      <span class="comment">// call.  The only question was the register address, which is the </span>
      <span class="comment">// concatenation of the command (010x = write DAC output) </span>
      <span class="comment">// and power down (x00x = power up) bits.</span>
      result <span class="keyword operator">=</span> <span class="function call">wiringPiI2CWriteReg16</span>(fd, <span class="constant numeric">0x40</span>, (i <span class="keyword operator">&</span> <span class="constant numeric">0xfff</span>) );

<span class="keyword">if</span>(result <span class="keyword operator">=</span><span class="keyword operator">=</span> <span class="keyword operator">-</span><span class="constant numeric">1</span>)
      {
         cout <span class="keyword operator"><</span><span class="keyword operator"><</span> <span class="string">"Error.  Errno is: "</span> <span class="keyword operator"><</span><span class="keyword operator"><</span> errno <span class="keyword operator"><</span><span class="keyword operator"><</span> endl;
      }
   }
}
</code>
</pre>
<p>Build it and link it to wiringPi using the following command.</p>
<div class="copy-code" data-code-id="code-10"><button class="btn btn-default btn-sm">COPY CODE</button></div>
<pre>
<code> g++ i2ctest.cpp -lwiringPi -o i2ctest
</code>
</pre>
<p>When you run <code>i2ctest</code>, the DAC will produce an analog sawtooth wave for a few seconds.</p>
<p><a href="http://bit.ly/1r9FY7Y" target="_blank"><img alt="alt text" src="http://bit.ly/1r9FY7Y" /></a></p>
<p><em>Waveform as measured at the <code>OUT</code> pin</em></p>
</div>
<div class="section tutorial-page">
<h2 id="i2c-0-on-40-pin-pi-boards">I2C-0 on 40-pin Pi Boards</h2>
<h3>An Extra I2C bus?</h3>
<p>As part of the B+ improvemets, the Raspberry Pi Foundation has standardized the interface to add-on boards, in what they call the <a href="http://bit.ly/24g3Jgq" target="_blank">“Hardware Added On Top” (HAT)</a> specification. It standardizes the physical form factor for add-on boards, and includes a provision for the B+ to automatically identify and initialize HATs at startup. It uses an I2C bus to read a description from an EEPROM on the HAT, similar to <a href="http://bit.ly/1r9FYod" target="_blank">cape identification</a> on the Beagle Bone Black.</p>
<p>This capability has been carried forward on the A+ and Pi 2 Model B as well. This I2C bus is found on the ID_SC and ID_SD pins (pins 27 and 28 of the 40-pin connector) – but before you get too excited about adding peripherals on that bus, observe the note in the schematic for that port.</p>
<p><a href="http://bit.ly/24g3Jgv" target="_blank"><img alt="B+ GPIO Pinout" src="http://bit.ly/1r9FXka" /></a></p>
<p><em>Schematic snippet for 40-Pin GPIO connector (J8).</em></p>
<p>This is further clarified in the <a href="http://bit.ly/24g3Lot" target="_blank">HAT design guide</a></p>
<blockquote>
<p>On a Model B+, GPIO0 (ID_SD) and GPIO1 (ID_SC) will be switched to ALT0 (I2C-0) mode and probed for an EEPROM. These pins will revert to inputs once the probe sequence has completed.</p>
<p>The only allowed connections to the ID_ pins are an ID EEPROM plus 3.9K pull up resistors. Do not connect anything else to these pins!</p>
</blockquote>
<p>It’s only there to talk to EEPROMs at addresses 0x50 during boot time. User access at runtime is problematic. If you want a general purpose I2C bus on the B+, you’ll need to use I2C-1, on pins 3 and 5 of the 40-pin connector, marked SDA and SCL on the Pi Wedge.</p>
<h3>Enabling I2C-0</h3>
<p>I2C-0 is disabled by default. To enable it, you’ll need to manually edit the configuration file.</p>
<p>Edit /boot/config.txt, and add the following line. If you previously used <code>raspi-config</code> to enable I2C-1 and SPI, you’ll see similar entries near the bottom of the vile.</p>
<div class="copy-code" data-code-id="code-11"><button class="btn btn-default btn-sm">COPY CODE</button></div>
<pre>
<code>dtparam=i2c_vc=on
</code>
</pre>
<p>With that enabled, restart your Pi (<code>sudo reboot</code>). When it’s back up, you’ll know it’s been activated is you’ve got a filesystem node at <code>/dev/i2c-0</code>.</p>
<h3>EEPROM Diagnostic Tools</h3>
<p>Alongside the HAT design guide, there is a directory with some <a href="http://bit.ly/1r9FXkb" target="_blank">software tools</a> for working with HAT EEPROMs. To use them, download them then <code>make</code> them from the command line.</p>
<p>We’ll explore how they’re used below.</p>
<h3>Testing I2C-0</h3>
<p>With the information above, we grabbed a <a href="http://bit.ly/24g3KAX" target="_blank">24LC256</a> EEPROM chip, and wired it to our Pi. We strapped all of the address pins to ground, which puts it at address 0x50, which we were able to confirm with <code>i2cdetect</code>.</p>
<p><a href="http://bit.ly/24g3Lou" target="_blank"><img alt="alt text" src="http://bit.ly/1r9FXkc" /></a></p>
<p><em>EEPROM on breadboard</em></p>
<p>Pull the EEPROM utilities mentioned above. The file <code>test_settings.txt</code> is a human-readable example of an EEPROM file. For testing purposes, we edited this file, changing the <em>vendor</em> and <em>product</em> fields to relevant information.</p>
<p>The text file itself needs to be processed into a binary format before it can be written to the EEPROM. The <code>eepmake</code>utility handles this conversion.</p>
<div class="copy-code" data-code-id="code-12"><button class="btn btn-default btn-sm">COPY CODE</button></div>
<pre>
<code>./eepmake  test_settings.txt test.eep
</code>
</pre>
<p>With the binary <code>test.eep</code> in hand, it can be programmed using the <code>eepflash.sh</code> script. It takes a number of parameters, which are explained if you run it with the <code>-h</code> flag. When writing the EEPROM, you’ll also have to approve of the operation by typing the full word <code>yes</code> when it prompts (<em>a simple <code>y</code> is not acceptable</em>). eepflash.sh will print out the status of the write – the 118 bytes written matches the length of the test.eep file we generated above.</p>
<div class="copy-code" data-code-id="code-13"><button class="btn btn-default btn-sm">COPY CODE</button></div>
<pre>
<code>sudo sh ./eepflash.sh -w -f=test.eep -t=24c256
This will disable the camera so you will need to REBOOT after this process completes.
This will attempt to write to i2c address 0x50. Make sure there is an eeprom at this address.
This script comes with ABSOLUTELY no warranty. Continue only if you know what you are doing.
Do you wish to continue? (yes/no): yes
Writing...
0+1 records in
0+1 records out
118 bytes (118 B) copied, 2.33811 s, 0.1 kB/s
Done.
</code>
</pre>
<p>As advised by that output, it is time to reboot.</p>
<p>When the system comes back up, you should have some new filesystem nodes at <code>/proc/device-tree/hat</code></p>
<div class="copy-code" data-code-id="code-14"><button class="btn btn-default btn-sm">COPY CODE</button></div>
<pre>
<code>pi@raspberrypi /proc/device-tree/hat $ ls -al
total 0
drwxr-xr-x  2 root root  0 Oct 27 20:16 .
drwxr-xr-x 15 root root  0 Oct 27 20:16 ..
-r--r--r--  1 root root  4 Oct 27 20:16 name
-r--r--r--  1 root root 21 Oct 27 20:16 product
-r--r--r--  1 root root  7 Oct 27 20:16 product_id
-r--r--r--  1 root root  7 Oct 27 20:16 product_ver
-r--r--r--  1 root root 37 Oct 27 20:16 uuid
-r--r--r--  1 root root 24 Oct 27 20:16 vendor
</code>
</pre>
<p>If we inspect the contents of those notes, we see the values that we put in the test_settings.txt file:</p>
<div class="copy-code" data-code-id="code-15"><button class="btn btn-default btn-sm">COPY CODE</button></div>
<pre>
<code>pi@raspberrypi/proc/device-tree/hat $ cat vendor
SparkFun Electronics

pi@raspberrypi /proc/device-tree/hat $ cat product
EEPROM Testing
</code>
</pre></div>
<div class="section tutorial-page">
<h2 id="tr">Troubleshooting</h2>
<p>If you’ve gone through raspi-config and enabled the SPI/I2c from ‘Advanced Options’, yet the devices are not in the device tree, don’t lose hope. There are two files that should be examined. We found that somtimes the raspi-config utility doesn’t solve the problem, depending on what version of Pi, where raspbian was sourced from, and when the last update has occurred.</p>
<h3>Check /boot/config.txt</h3>
<p>Sometimes the raspi-config tool will incorrectly edit /boot/config.txt while selecting the advanced settings. What happens is an erroneous control-char is placed in the file.</p>
<div class="well"># NOOBS Auto-generated Settings:<br />
hdmi_force_hotplug=1<br />
config_hdmi_boost=4<br />
overscan_left=24<br />
overscan_right=24<br />
overscan_top=16<br />
overscan_bottom=16<br />
disable_overscan=0^Mdtparam=spi=on<br />
dtparam=i2c_arm=on</div>
<p><em>After configuration with raspi-config, /boot/config.txt contains a strange <code>^M</code> character</em></p>
<p>Fix the line breaking in the file so it looks something like this:</p>
<div class="well"># NOOBS Auto-generated Settings:<br />
hdmi_force_hotplug=1<br />
config_hdmi_boost=4<br />
overscan_left=24<br />
overscan_right=24<br />
overscan_top=16<br />
overscan_bottom=16<br />
disable_overscan=0<br />
dtparam=spi=on<br />
dtparam=i2c_arm=on</div>
<h3>Check /etc/modules</h3>
<p>If they are not present, add the following to the end of <code>/etc/modules</code></p>
<div class="well">spi-dev<br />
i2c-dev</div>
<h3>Reboot the system</h3>
<p>After checking the files, reboot by issuing <code>sudo reboot</code> or <code>sudo shutdown -r now</code>.</p>
</div>
<div class="section tutorial-page">
<h2 id="resources--going-further">Resources & Going Further</h2>
<h2>Resources</h2>
<ul>
<li>If you’re really curious about the nitty-gritty internal details of I2C and SPI, you might want to read the source code of Wiring Pi, which you can clone from <a href="http://bit.ly/24g3Low" target="_blank">here</a>.</li>
<li>Additionally, you can learn about the Linux underpinnings of these interfaces documented at <a href="http://bit.ly/1r9FYoi" target="_blank">kernel.org</a>. The <a href="http://bit.ly/24g3LoF" target="_blank">SPI</a>documentation seems to be more complete than its <a href="http://bit.ly/1r9FYoj" target="_blank">I2C</a> sibling.</li>
<li>If the example code here isn’t working, you should check for updated versions on the 40-pin Pi Wedge <a href="http://bit.ly/24g3Mc0" target="_blank">GitHub Repository</a>.</li>
<li>The way that I2C and SPI devices are enabled in Raspbian has changed significantly in recent revisions.  <a href="http://bit.ly/1r9FYok" target="_blank">This forum post</a> explains how to re-enable the interfaces if they disappeared in an upgrade.</li>
<li>The HAT specifications and related information are hosted on <a href="http://bit.ly/24g3LoI" target="_blank">GitHub</a>. If you’re designing a HAT, you’ll want to start by reading the <a href="http://bit.ly/24g3Lot" target="_blank">HAT Design Guide</a>, and possibly perusing the <a href="http://bit.ly/1r9FXkh" target="_blank">B+ addons</a> forum.</li>
<li><a href="http://bit.ly/24g3Mc6" target="_blank">Filezilla</a> is a convenient FTP & SFTP client, which is useful for getting files to and from a Pi.</li>
<li><a href="http://bit.ly/24g3IJw" target="_blank">PuTTY</a> is a terminal program that has serial, telnet and SSH modes.</li>
</ul>
<h2>Going Further</h2>
<ul>
<li>The Pi <a href="http://bit.ly/1r9FYon" target="_blank">gPIo tutorial</a> explains how to use the digital I/O pins on your Pi.</li>
<li>The <a href="http://bit.ly/24g3Mc7" target="_blank">Pi Wedge</a> gives you a convenient way to access the SPI and I2C interfaces on your Pi.</li>
</ul>
<p>For more information about the Raspberry Pi and the software described here, please visit their sites.</p>
<ul>
<li><a href="http://bit.ly/1r9FXkm" target="_blank">The Raspberry Pi Foundation</a></li>
<li>The Pi Foundation’s <a href="http://bit.ly/1r9FXkh" target="_blank">B+ Addons</a> forum.</li>
<li>The Pi Foundation’s GitHub repository for the <a href="http://bit.ly/24g3LoI" target="_blank">Raspberry Pi B+ HATs</a>.</li>
<li>The eLinux.org <a href="http://bit.ly/24g3Mcc" target="_blank">Raspberry Pi peripherals</a> guide</li>
<li><a href="http://wiringpi.com/" target="_blank">WiringPi</a></li>
<li><a href="http://bit.ly/1r9FYou" target="_blank">RPi.GPIO module</a></li>
<li>Some notes about increasing the available current from the <a href="http://bit.ly/24g3LF2" target="_blank">B+ USB ports</a>.</li>
</ul>
<p>If you have any problems or questions, our <a href="http://bit.ly/1r9FXkq" target="_blank">technical support department</a> can help. Please don’t hesitate to contact us. We also love to hear about your projects!</p>
</div>
<p> </p>
<p> </p>
<p> </p>
<div id="huge-it-share-buttons-top" class="huge-it-share-buttons nobackground">
<h3>Share This:</h3>
<ul class="huge-it-share-buttons-list">
<li class=" nobackground"><a href="http://bit.ly/1XReO0c" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1XReO0c','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -0px -120px" target="_blank"></a></li>
<li class=" nobackground"><a href="https://twitter.com/share?status=http://yoursmart.mobi/feed&text=Raspberry%20Pi%20SPI%20and%20I2C%20Tutorial" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('https://twitter.com/share?status=http://yoursmart.mobi/feed&text=Raspberry Pi SPI and I2C Tutorial','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -30px -120px" target="_blank"></a></li>
<li class=" nobackground"><a href="http://bit.ly/1UhB2JO%20Pi%20SPI%20and%20I2C%20Tutorial" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1UhB2JO Pi SPI and I2C Tutorial','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -60px -120px" target="_blank"></a></li>
<li class=" nobackground"><a href="http://bit.ly/1XReO0d" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1XReO0d','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -90px -120px" target="_blank"></a></li>
<li class=" nobackground"><a href="http://bit.ly/1qUAv4w%20Pi%20SPI%20and%20I2C%20Tutorial&mini=true&url=http://bit.ly/1XReO0g" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1qUAv4w Pi SPI and I2C Tutorial&mini=true&url=http://bit.ly/1XReO0g','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -120px -120px" target="_blank"></a></li>
<li class=" nobackground"><a href="http://bit.ly/1UhB2JR%20Pi%20SPI%20and%20I2C%20Tutorial" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1UhB2JR Pi SPI and I2C Tutorial','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -150px -120px" target="_blank"></a></li>
<li class=" nobackground"><a href="http://di.gg/1qUAw8H%20Pi%20SPI%20and%20I2C%20Tutorial" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://di.gg/1qUAw8H Pi SPI and I2C Tutorial','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -180px -120px" target="_blank"></a></li>
<li class=" nobackground"><a href="http://stumble.it/1UhB04J%20Pi%20SPI%20and%20I2C%20Tutorial" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://stumble.it/1UhB04J Pi SPI and I2C Tutorial','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -210px -120px" target="_blank"></a></li>
<li class=" nobackground"><a href="http://bit.ly/1XReO0l" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1XReO0l','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -240px -120px" target="_blank"></a></li>
<li class="none nobackground"><a href="http://bit.ly/1qUAvSg%20Pi%20SPI%20and%20I2C%20Tutorial" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1qUAvSg Pi SPI and I2C Tutorial','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -270px -120px" target="_blank"></a></li>
<li class="none nobackground"><a href="http://bit.ly/1UhB2JW%20Pi%20SPI%20and%20I2C%20Tutorial" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1UhB2JW Pi SPI and I2C Tutorial','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -300px -120px" target="_blank"></a></li>
<li class="none nobackground"><a href="http://bit.ly/1VNpzTU" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1VNpzTU','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -330px -120px" target="_blank"></a></li>
<li class="none nobackground"><a href="http://bit.ly/1qUAw8P%20Pi%20SPI%20and%20I2C%20Tutorial" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1qUAw8P Pi SPI and I2C Tutorial','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -360px -120px" target="_blank"></a></li>
<li class="none nobackground"><a href="http://bit.ly/1VNpzTX" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1VNpzTX','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -390px -120px" target="_blank"></a></li>
<li class="none nobackground"><a href="http://bit.ly/1UhB04O%20Pi%20SPI%20and%20I2C%20Tutorial" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1UhB04O Pi SPI and I2C Tutorial','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -420px -120px" target="_blank"></a></li>
<li class="none nobackground"><a href="http://bit.ly/1qUAv4D%20Pi%20SPI%20and%20I2C%20Tutorial&pic=&ralateUid=&" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1qUAv4D Pi SPI and I2C Tutorial&pic=&ralateUid=&','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -450px -120px" target="_blank"></a></li>
<li class="none nobackground"><a href="http://bit.ly/1UhB30d%20Pi%20SPI%20and%20I2C%20Tutorial" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1UhB30d Pi SPI and I2C Tutorial','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -480px -120px" target="_blank"></a></li>
<li class="none nobackground"><a href="http://bit.ly/1qUAwp8%20Pi%20SPI%20and%20I2C%20Tutorial" id="backforunical599" name="backforunical599" onclick="javascript:void window.open('http://bit.ly/1qUAwp8 Pi SPI and I2C Tutorial','1410949501326','width=700,height=500,toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=1,left=0,top=0');return false;" style="background-position: -510px -120px" target="_blank"></a></li>
</ul>
<div class="clear"></div>
</div>
View more at: <a href="http://bit.ly/1XReQFr">http://bit.ly/1XReQFr</a>

Raspberry Pi SPI and I2C Tutorial

There are many peripherals that can be added to a microprocessor over the I2C and SPI serial interfaces. These include atmospheric sensors, EEPROMS, and several types of display. The Pi Wedge helps a…

Raspberry Pi SPI and I2C Tutorial

Contact Form