Matrix Keypad with I2C Adapter (4x4, PCF8574)

What it does

A 4×4 matrix keypad is sixteen switches wired as four row wires and four column wires: pressing a key joins one row to one column. That is eight wires, and wired straight to a board it is eight GPIO pins — nearly half an Arduino Uno.

The adapter moves those eight wires onto a PCF8574, a chip with eight pins of its own that is controlled over I²C. What is left on your board is the I²C bus: SDA and SCL, plus power and ground. Screens, sensors and clocks share the same two wires, each at its own address. The adapter ships at 0x20.

The I2CKeyPad library by Rob Tillaart reads a key with two writes and two reads, and returns a number from 0 to 15. A keymap string turns that into the character printed on the key.

The boxes

Three products carry the same adapter circuit. What differs is the keypad.

The TinkerBlock TK85, above, is the adapter on a TinkerBlock board with mounting holes for the base plate, and comes in the 46-piece kit.

Which keymap

The soft keypad brings its rows out first and the heavy-duty keypad its columns, so the same key lands on a different number. A keypad from anywhere else: run the keymap finder.

Wiring, in four lines

1. GND to the board's GND.
2. VCC to the board's own logic voltage: 5V on an Uno, 3V3 on an ESP32.
3. SDA to the board's SDA: A4 on an Uno, GPIO 21 on an ESP32, GPIO 8 on an ESP32-S3.
4. SCL to the board's SCL: A5, GPIO 22, GPIO 9.

VCC matters because the adapter's own 10 kΩ pull-ups tie SDA and SCL to it. Fed from 5 V next to an ESP32, the bus idles at 5 V against 3.3 V pins.

Two on one bus

Every adapter ships at 0x20. Two on the same board need different addresses, set by bridging one of the three pads on the back with solder. The pads printed A0 and A2 are wired the other way round: bridging the one marked A0 gives 0x24, and the one marked A2 gives 0x21. Scan after soldering and use what it prints.

Each adapter also brings a pair of 10 kΩ pull-ups. With more than a handful on one bus, cut the I2C PULL UP pad on all but one. More than one keypad works through both.

Example

Install I2CKeyPad from the Arduino Library Manager. The MicroPython version does the same two reads by hand and needs no library.

#include <Wire.h>
#include "I2CKeyPad.h"

// 16 keys, then N (no key) and F (fail). Pick the one for your keypad.
char keymap[19] = "DCBA#9630852*741NF";      // soft keypad
// char keymap[19] = "D#0*C987B654A321NF";   // heavy-duty keypad

I2CKeyPad keyPad(0x20);
char last = 'N';

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(100000);   // the PCF8574 is rated for 100 kHz
  if (!keyPad.begin()) {
    Serial.println("No keypad at 0x20");
    while (true) delay(1000);
  }
  keyPad.loadKeyMap(keymap);
}

void loop() {
  char c = keyPad.getChar();
  if (c != last) {
    if (c != 'N' && c != 'F') Serial.println(c);
    last = c;
  }
  delay(20);
}

from machine import Pin, I2C
import time

ADDRESS = 0x20
KEYMAP = "DCBA#9630852*741"      # soft keypad
# KEYMAP = "D#0*C987B654A321"    # heavy-duty keypad

# Raspberry Pi Pico: I2C0 on GP0 (SDA) and GP1 (SCL). Change the pins for your board.
i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=100_000)

ONE = {0xE: 0, 0xD: 1, 0xB: 2, 0x7: 3}   # exactly one line low

def read(mask):
    i2c.writeto(ADDRESS, bytes([mask]))
    return i2c.readfrom(ADDRESS, 1)[0]

def get_key():
    upper = (read(0xF0) >> 4) & 0x0F   # which of P4-P7 the key pulled low
    lower = read(0x0F) & 0x0F          # which of P0-P3 the key pulled low
    if upper == 0x0F or lower == 0x0F:
        return None                    # no key
    if upper not in ONE or lower not in ONE:
        return "F"                     # two keys at once
    return KEYMAP[ONE[upper] + 4 * ONE[lower]]

last = None
while True:
    key = get_key()
    if key != last and key not in (None, "F"):
        print(key)
    last = key
    time.sleep_ms(20)

Where to start

The handbook below is eleven short articles with a working figure in each. If you only read one, read one adapter, two keymaps. If you want keys on the serial monitor now, the first keypress is the whole build.