MCP23017 tutorial: 16 more GPIOs over i2c

The trade

Two pins in, sixteen GPIOs out

An expander is the cleanest deal in embedded: SDA and SCL are a shared bus, so those two pins were already spoken for by every other sensor you own. Adding an MCP23017 costs nothing extra in host pins and returns 16 fully-featured GPIOs.

They're not second-class pins either. Each one is push-pull — it can actively drive high or low — with a direction register, an optional internal pull-up, polarity inversion, and interrupt-on-change. The only thing they can't do is speed: every read or write is an i2c transaction, so you're looking at microseconds, not the nanoseconds of a native pin. For buttons, LEDs, relays and switches — the things you actually run out of pins for — that's irrelevant.

And it stacks. Three address pins give eight addresses (0x20–0x27), so eight chips is 128 GPIOs on the same two wires.

Pick the right chip

MCP23017 vs PCF8574: not a close call

Both are "i2c GPIO expanders" at similar prices, and they're genuinely different chips. The PCF8574 is the one most people meet first — usually without realising, because it's the chip on every i2c LCD backpack.

"Quasi-bidirectional" is the PCF8574's real limitation. It has no direction register: you make a pin an input by writing a 1 and then reading it back. That 1 isn't a strong drive, it's a weak internal pull-up — so a PCF8574 output can sink current properly but barely source any. Drive an LED from it high-side and you get a sad glow. The MCP23017 just drives the pin.

Take the PCF8574 when you want eight cheap outputs, or when you're talking to an LCD backpack that already has one. Take the MCP23017 for everything else. Both share 0x20–0x27, so they collide on one bus — see the collision roundup, and note the XL9535 relay boards sit in the same block.

Step 1

MCP23017 wiring and the address pins

• VCC / GND — 3.3–5 V, so it suits a Pi or an Uno.
• SDA / SCL — to your host, same as everything else on the bus.
• RESET — tie it high. It's active-low, and floating it means random resets. This is the number one reason a fresh MCP23017 "works intermittently".
• A0 / A1 / A2 — each to GND or VCC. All three to GND gives 0x20; the pins read as a 3-bit number added to that base, so A0 high alone is 0x21, all three high is 0x27.
• GPA0–GPA7 / GPB0–GPB7 — your sixteen pins, in two 8-bit banks. INTA / INTB are optional interrupt outputs.

Then scan and confirm 0x20 before writing code. If the address is wrong, it's the A-pins; if it's flaky, it's RESET.

Step 2

MCP23017 Arduino code: a button and an LED

Install Adafruit's MCP23017 library, then:

#include <Adafruit_MCP23X17.h>

Adafruit_MCP23X17 mcp;

void setup() {
  Serial.begin(115200);
  if (!mcp.begin_I2C(0x20)) {          // A0-A2 all tied to GND
    Serial.println("No MCP23017 at 0x20 — check A0-A2 and RESET");
    while (1);
  }
  mcp.pinMode(0, OUTPUT);              // GPA0 -> LED (with a resistor!)
  mcp.pinMode(8, INPUT_PULLUP);        // GPB0 -> button to GND
}

void loop() {
  // pressed == LOW, because the internal pull-up holds it high when open
  bool pressed = (mcp.digitalRead(8) == LOW);
  mcp.digitalWrite(0, pressed ? HIGH : LOW);
  delay(20);                            // crude debounce
}

That's deliberately familiar: pinMode, digitalRead, digitalWrite — the same names as native pins, just with an object in front. Pins 0–7 are bank A, 8–15 are bank B.

INPUT_PULLUP is doing real work here. It enables the chip's own ~100 kΩ pull-up on that pin, so a button wired straight to ground needs no external resistor. Wire sixteen buttons and you need sixteen buttons — nothing else. (These are the GPIO pull-ups, not the bus pull-ups on SDA/SCL, which are a separate matter your breakout probably already handles.)

Step 3

MCP23017 registers: what the library is hiding

Worth seeing once, because it makes the datasheet readable. The chip is three registers per bank:

Each is one byte, one bit per pin. So the whole of the sketch above is: write IODIRA to make GPA0 an output, write IODIRB to make GPB0 an input, set the matching GPPUB bit for its pull-up, then read GPIOB and write GPIOA in a loop.

Note everything is an input at reset — which is the safe default, and why a freshly-powered expander drives nothing until you tell it to.

You can poke these by hand. On a Pi, no code at all:

# make all of bank A outputs (IODIRA = 0x00)
i2cset -y 1 0x20 0x00 0x00
# drive GPA0 high (GPIOA = 0x01)
i2cset -y 1 0x20 0x12 0x01
# read bank B (GPIOB)
i2cget -y 1 0x20 0x13

Going further

Interrupts, and 128 pins on two wires

Stop polling. Reading sixteen buttons in a loop means hammering the bus forever to discover nothing changed. The MCP23017's interrupt-on-change flips it: tell it which pins to watch, wire INTA or INTB to a spare host GPIO, and it tells you. That's the standard answer to i2c having no "data ready" signal of its own — the same reason a laptop touchpad has a dedicated interrupt line.

The two banks have separate INT pins, so you can watch buttons on bank B while bank A drives outputs, and only get interrupted by the half you care about.

Stacking: eight addresses × 16 pins = 128 GPIOs on the same SDA/SCL. The limits are the usual ones — each board adds its pull-ups in parallel and more bus capacitance. And watch the current: about 25 mA per pin but only ~150 mA for the whole package, so sixteen LEDs at 20 mA is already over budget. For lots of LEDs, a PCA9685 is the right chip; for relays, drive them from their own supply.