MCP23017

Microchip’s MCP23017 can be purchased for as little as $1.99; it communicates with the Pi over the I2C bus. Because the I2C bus requires only two power lines and two data lines, it needs only a four-conductor ribbon cable and thus can cover some distance. Figure 11-2 shows the schematic pinout.

Figure 11-2. MCP23017 pinout

The active low RESET pin can be tied to the supply if not required, since a software reset is still possible. The signal forces a chip reset like the name implies.

The SCL and SDA are the two I2C communication connections. Chip inputs A0 through A2 allow you to configure the I2C address for the chip. Grounding them gives the chip address 0x20. Table 11-1 summarizes the addresses.

The INTA and INTB output pins are optional signals that can provide interrupt notification to the Raspberry Pi over one or two GPIO ports. The remaining pins GPA0 through GPA7 and GPB0 through GPB7 provide 16 more GPIO ports, which are under software configuration control.

Wiring

Figure 11-3 shows the wiring necessary to attach the MCP23017 to the Raspberry Pi. On the breadboard, simply wire the T-Cobbler connections marked SCL and SDA to pins 12 and 13, respectively.

Figure 11-3. MCP2301 wired to the Raspberry Pi

Make certain that the RESET pin is also wired to the supply so that it doesn’t become active. For simplicity and agreement with the provided software, connect inputs A0 through A2 to ground. This configures the chip to respond to I2C address 0x20. Signals INTA and INTB are outputs and can be ignored for the moment.

After reset, the MCP23017 chip automatically configures all the GPAx and GPBx pins as inputs, without a pull-up resistor. This is not ideal because this leaves the CMOS inputs floating. But for this initial experiment, the chip should tolerate it.

If you haven’t already done so, install i2c-tools.

$ sudo apt-get install i2c-tools

Once installed, then list your I2C buses.

$ i2cdetect -l

If nothing is displayed, then you need to make sure that the I2C drivers get loaded. The new kernels now use the /boot/config.txt file to enable I2C support. Edit the file so that the i2c line is uncommented as follows:

# Uncomment some or all of these to enable the optional hardware interfaces
dtparam=i2c_arm=on
#dtparam=i2s=on
#dtparam=spi=on

Save your changes and reboot to try again.

sudo /sbin/shutdown -r now

After the reboot, list the I2C buses again.

$ i2cdetect -l
i2c-1 i2c 3f804000.i2c I2C adapter

From this, you now see i2c-1 is available as expected. Now probe for your MCP23017 device. The command-line argument 1 shown next indicates to scan bus i2c-1.

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

If all was successful, you should see a “20” listed among the hyphens. This tells you that the device is reachable on the i2c-1 bus.

Output GPIO Experiment

With your breadboard wired according to Figure 11-3, you can perform a GPIO output test. Enter the subdirectory mcp23017 in the source code and type make to build the programs there. Once that is done, you can run the output test.

$ ./mcp_out
GPIOA = 0x0B
GPIOB = 0xC1

This program will write the hexadecimal value 0x0B to GPIO port A and 0xC1 to GPIO port B. You’ll examine the source code later.

With your DMM or an LED and dropping resistor (refer to Figure 10-4 in Chapter 10), probe the MCP23017 GPIO output pins. With this program run, you should observe the values listed in Table 11-2. Pay special attention to the chip pin numbers when wiring or taking readings. The pins for GPIOA and GPIOB are physically laid out in reverse order from each other.

Figure 11-4 illustrates my breadboard setup. One nice aspect of I2C is the wiring simplicity. The plastic DIP (PDIP) form of the chip consists of 28 pins. The pin arrangement is somewhat unusual in that the V_DD (+3.3V) goes to pin 9, while pin 10 (V_SS) is the ground connection. Be sure that the RESET pin is wired high or it will sporadically reset or stay in reset mode. The remaining white wires shown in Figure 11-4 ground A0 through A2 so that the I2C address is established as hex 0x20.

Figure 11-4. MCP23017 breadboard setup

Input Experiment

With no change to the breadboard circuit, you can now run an input experiment. This is one area that the I2C peripheral excels: it can software reconfigure the 16 GPIO pins as outputs or inputs. With the program compiled earlier (in the mcp23017 subdirectory), you can just invoke mcp_in.

$ ./mcp_in
GPIOA = 0xFF, GPIOB = 0xFF
GPIOA = 0xBF, GPIOB = 0xFF
GPIOA = 0xFF, GPIOB = 0xFF
GPIOA = 0xDF, GPIOB = 0xFF
GPIOA = 0xFF, GPIOB = 0xFF
GPIOA = 0xDF, GPIOB = 0xFF
GPIOA = 0xFF, GPIOB = 0xFF
GPIOA = 0xFF, GPIOB = 0xFD
GPIOA = 0xFF, GPIOB = 0xFF
GPIOA = 0xFF, GPIOB = 0xFD
GPIOA = 0xFF, GPIOB = 0xFF
GPIOA = 0xFF, GPIOB = 0xFD
GPIOA = 0xFF, GPIOB = 0xFF
GPIOA = 0xFF, GPIOB = 0xFD

Initially, you will see only the following line:

GPIOA = 0xFF, GPIOB = 0xFF

After you see this initial report, ground one end of a Dupont wire (to the Pi). With the other end of the wire, touch or insert the wire in various places for GPIO A or GPIO B. Be careful not to touch any other pins, however. As you do this, changes in the input port (or ports) will be reported on your console session. Sometimes there will be “stutter” output. This is because of the speed of the Pi and the contact bouncing or scratching that occurs.

When the joy of the experiment diminishes, press ^C (Control-C) to end the program.

Software Operations

The flexibility of the MCP23017 GPIO peripheral requires extra responsibility on the software side. To complicate things further, Microchip provides two methods for addressing registers within its chip. This is configured by the IOCON.BANK bit. This chapter assumes IOCON.BANK=0, including the software provided. This results in the registers being laid out as in Table 11-3.

In this discussion, please keep in mind that the I2C and register addresses are two different entities. The register address allows you to access registers within the peripheral, while the I2C address allows you to select the peripheral device.

Essentially, Table 11-3 shows that the least significant bit in this mode selects GPIO A or B, with the register selection shifted left one bit. Hence, within the program, you make use of the following macros:

#define IODIR                   0
#define IPOL                    1
#define GPINTEN                 2
#define DEFVAL                  3
#define INTCON                  4
#define IOCON                   5
#define GPPU                    6
#define INTF                    7
#define INTCAP                  8
#define GPIO                    9
#define OLAT                    10

#define GPIOA                   0
#define GPIOB                   1

#define MCP_REGISTER(r,g) (((r)<<1)|(g))

Using these macros, you can select register IODIR for GPIOB using MCP_REGISTER(IODIR,GPIOB) in the code.

#include <sys/ioctl.h>
#include <linux/i2c.h>
#include <linux/i2c-dev.h>

036 static const char *i2c_device = "/dev/i2c-1";
037 static int i2c_fd = -1;

093 int
094 main(int argc,char **argv) {
095   int rc;
096
097   i2c_fd = open(i2c_device,O_RDWR);
098   if ( i2c_fd == -1 ) {
099          fprintf(stderr,"%s: opening %s\n",
100                strerror(errno),
101                i2c_device);
102          exit(1);
103  }

062 static int
063 i2c_write(int addr,int reg,int ab,uint8_t byte) {
064   struct i2c_rdwr_ioctl_data msgset;
065   struct i2c_msg iomsgs[1];
066   uint8_t reg_addr = MCP_REGISTER(reg,ab);
067   uint8_t buf[2];
068   int rc;
069
070   buf[0] = reg_addr;
071   buf[1] = byte;
072
073   iomsgs[0].addr = unsigned(addr);
074   iomsgs[0].flags = 0;
075   iomsgs[0].buf = buf;
076   iomsgs[0].len = 2;
077
078   msgset.msgs = iomsgs;
079   msgset.nmsgs = 1;
080
081   rc = ioctl(i2c_fd,I2C_RDWR,&msgset);
082   return rc < 0 ? -1 : 0;
083 }

062 int
063 i2c_read_data(int addr,int ab,uint8_t& byte) {
064   struct i2c_rdwr_ioctl_data msgset;
065   struct i2c_msg iomsgs[2];
066   uint8_t txbuf[1];
067   int rc;
068
069   txbuf[0] = MCP_REGISTER(GPIO,ab);
070
071   iomsgs[0].addr = iomsgs[1].addr = unsigned(addr);
072   iomsgs[0].flags = 0;            // Write
073   iomsgs[0].buf = txbuf;
074   iomsgs[0].len = 1;
075
076   iomsgs[1].flags = I2C_M_RD;     // Read
077   iomsgs[1].buf = &byte;          // Pass back data byte
078   iomsgs[1].len = 1;
079
080   msgset.msgs = iomsgs;
081   msgset.nmsgs = 2;
082
083   rc = ioctl(i2c_fd,I2C_RDWR,&msgset);
084   return rc < 0 ? -1 : 0;
085 }

129  rc = i2c_write_both(i2c_addr,IOCON,0b01000100);  // MIRROR=1,ODR=1
130  assert(!rc);
131
132  rc = i2c_write_both(i2c_addr,GPINTEN,0x00);  // No interrupts enabled
133  assert(!rc);
134
135  rc = i2c_write_both(i2c_addr,DEFVAL,0x00);  // Clear default value
136  assert(!rc);
137
138  rc = i2c_write_both(i2c_addr,OLAT,0x00);     // OLATx=0
139  assert(!rc);
140
141  rc = i2c_write_both(i2c_addr,IPOL,0b00000000);  // No inverted polarity
142  assert(!rc);
143
144  rc = i2c_write_both(i2c_addr,GPPU,0b11111111);  // Enable all pull-ups
145  assert(!rc);
146
147  rc = i2c_write_both(i2c_addr,IODIR,0b11111111);  // All are inputs
148  assert(!rc);

Interrupt Capability

Earlier you saw a demonstration of reading MCP23017 GPIO inputs. But if the inputs are attached to push buttons, for example, how does your program stay informed without constantly polling the peripheral? You could continuously perform I2C read operations as the mcp_in.cpp program does, but this keeps the I2C bus very busy.

Microchip provides a feature in the MCP23017 peripheral to provide one or two interrupt signals for input signal changes. You may configure it for separate GPIO A and B interrupts, or you may configure it to use one pin for both. Pins 19 and 20 of the chip provide the interrupt signals.

The next demonstration will use one pin (INTA pin 20) to signal a change of GPIO input, whether for GPIO A or B. To do this, you must the set the peripheral’s configuration.

• IOCON.MIRROR = 1 (INTA represents both GPIO A and B).

• IOCON.ODR = 0 (when true, the INTA is in “open drain” configuration)

• IOCON.INTPOL = 0 (you’re going to make the INTA pin active low; this applies only when ODR=0).

• GPINTEN.BPINTx bits 0 through 7 enable interrupts for each pin (1=enabled)

• INTCON.IOCx bits 0 through 7 are either:

  • Compared to the DEFVAL register (when set to 1)

  • Compared to self (when set to 0)

• DEFVAL.DEFx bits 0 through 7 set the compare value for interrupts (optionally)

The DEFVAL settings apply only if you enable DEFVAL in IOCON.IOCx. For example, if IOCON.IOC2 for GPIOB is set to 1, then DEFVAL.DEF2 is used to compare against the GPIO B input 2. If the values differ, an interrupt is generated.

You’re going to use INTCON.IOCx=0 so that the interrupt occurs on any change in the input signal. In this configuration, the DEFVAL bit setting has no influence. You can think of this configuration as comparing the input against its last known value.

The program being used for this experiment is named mcp_int.cpp. By default, this program assumes you have connected GPIO#5 to the MCP23017 INTA pin 20. If you need to change this to something else, then this is the line you need to edit:

041 static int gpio_inta = 5;  // GPIO for INTA signal

The main routine configures the peripheral for interrupts as described earlier. This is illustrated in Listing 11-5.

Listing 11-5. MCP23017 Interrupt Configuration

144   rc = i2c_write_both(i2c_addr,IOCON,0b01000000);  // MIRROR=1,ODR=0,INTPOL=0
145   assert(!rc);
146
147   rc = i2c_write_both(i2c_addr,IODIR,0xFF);  // All are inputs
148   assert(!rc);
149
150   rc = i2c_write_both(i2c_addr,INTCON,0x00);  // Interrupts compare to self
151   assert(!rc);
152
153   rc = i2c_write_both(i2c_addr,GPINTEN,0xFF);  // All interrupts enabled
154   assert(!rc);
155
156   rc = i2c_write_both(i2c_addr,IPOL,0x00);  // No inverted input polarity
157   assert(!rc);
158
159   rc = i2c_write_both(i2c_addr,GPPU,0xFF);  // Enable all pull-ups
160   assert(!rc);

The comments indicate the configuration values being set. For simplicity, mcp_int.cpp sets all GPIO pins as inputs. Once all the configuration is performed, the main program enters its main loop, shown in Listing 11-6.

Listing 11-6. Main Loop for Interrupt Processing

162   {
163         uint8_t gpioa, gpiob, inta, intf_a = 0, intf_b = 0;
164
165          rc = i2c_read_data(i2c_addr,GPIOA,GPIO_,gpioa);
166          assert(!rc);
167
168          rc = i2c_read_data(i2c_addr,GPIOB,GPIO_,gpiob);
169          assert(!rc);
170
171          printf("GPIOA 0x%02X INTFA 0x%02X, GPIOB 0x%02X INTFB 0x%02X\n",
172                gpioa, intf_a,
173                gpiob, intf_b);
174
175          for (;;) {
176                inta = gpio.read(gpio_inta);
177                if ( inta != 0 ) {
178                      // No interrupt
179                      usleep(1);
180                      continue;
181                }
182
183                // Process interrupt
184
185                rc = i2c_read_data(i2c_addr,GPIOA,INTF,intf_a);
186                assert(!rc);
187
188                rc = i2c_read_data(i2c_addr,GPIOB,INTF,intf_b);
189                assert(!rc);
190
191                rc = i2c_read_data(i2c_addr,GPIOA,INTCAP,gpioa);
192                assert(!rc);
193
194                rc = i2c_read_data(i2c_addr,GPIOB,INTCAP,gpiob);
195                assert(!rc);
196
197                printf("GPIOA 0x%02X INTFA 0x%02X, GPIOB 0x%02X INTFB 0x%02X\n",
198                      gpioa, intf_a,
199                      gpiob, intf_b);
200          }
201    }

Lines 165 to 173 simply report the current state of the MCP23017 inputs prior to entering the loop. The loop, starting in line 175, polls Raspberry Pi GPIO (#5) to see whether the chip is reporting an interrupt. If the INTA line is high, there is no interrupt being reported, so a short sleep is performed and the loop is restarted (lines 177 to 181).

If the Raspberry Pi GPIO (#5) is low, this indicates that one or both of the MPC23017 ports has registered a change on an input pin. Lines 185 to 189 read the INTF register for GPIO A and GPIO B. This register sets a 1 bit where an input value has changed. Lines 191 to 195 read the interrupt capture register for GPIO A and B. These registers reflect the input line states at the time of the interrupt. Lines 197 to 199 simply report the changes.

Figure 11-5 shows how to wire the circuit for the interrupt test. The only new connection is the connection going from the Raspberry Pi’s GPIO #5 to the INTA pin 20 of the peripheral.

Figure 11-5. MCP23017 wired for interrupt signaling

After wiring according to Figure 11-5, run the program mcp_int. All chip pins are configured as input with a pull-up resistor so that they will read high with no connections to them. While the program was running in the following session, I touched a ground wire to GPA5 (bit 5 of GPIOA on pin 28) in the example session shown here:

$ ./mcp_int
GPIOA 0xFF INTFA 0x00, GPIOB 0xFF INTFB 0x00
GPIOA 0xDF INTFA 0x20, GPIOB 0xFF INTFB 0x00
GPIOA 0xFF INTFA 0x20, GPIOB 0xFF INTFB 0x00
GPIOA 0xFF INTFA 0x20, GPIOB 0xFF INTFB 0x00
GPIOA 0xFF INTFA 0x20, GPIOB 0xFF INTFB 0x00

The first line is simply the initial reported setting. The program will wait there until you do something (like grounding an input). The second line reports that GPIOA captured the hex value DF as part of the change (in the first line reported as FF). The INTFA register reports 20, indicating the bit that changed (bit 5). This confirms that the GPA5 went from a 1 bit to a 0 bit.

Because of the rate of changes, sometimes you will register changes but not see them in the capture register. In the example session, INTFA continues to register the fact that bit 5 changed but showed no change in the captured value (FF). Because of contact bouncing (of my Dupont wire), the chip registered a change, but the state of the input changed back to a 1 bit by the time the capture was made.

Interrupt Profit and Loss

What did you gain from the use of the INTA pin? This pin is intended by Microchip for use as a real interrupt signal for a microcomputer. Here you attached it to the Pi’s GPIO #5 and polled that signal for changes. So, what did you gain?

While you still utilized polling, you polled a single Pi GPIO, which is far cheaper than continuously sending I2C read commands to the bus. By polling a Pi GPIO, you freed up available bandwidth on the I2C bus, which might be used for other devices. The I2C bus was used only when needed.

Summary

While the 74HC165 and 74HC595 parts were easy to use, they were not reconfigurable. The MCP23017, however, offers 16 fully software configurable GPIO pins. The price of this is the additional software complexity. The chip also provides additional interrupt input processing that is absent in the simpler 74HC165 and 74HC595 parts. Finally, the ability to connect several devices to the I2C bus makes the MCP23017 a flexible peripheral, whether the device is local or remote to the Raspberry Pi.