#include "Wire.h"
#include "I2CKeyPad.h"
const uint8_t KEYPAD_ADDRESS = 0x20;

// P7 C4
// P6 C3
// P5 C2
// P4 C1
// P3 R4
// P2 R3
// P1 R2
// P0 R1

I2CKeyPad keyPad(KEYPAD_ADDRESS);

uint32_t start, stop;
uint32_t lastKeyPressed = 0;

void setup() {
  Serial.begin(115200);

  Wire.begin();
  Wire.setClock(400000);

  if (keyPad.begin() == false) {
    Serial.println("\nERROR: cannot communicate to keypad.\nPlease reboot.\n");
    while(1);
  }
}

void loop() {
  uint32_t now = millis();
  char keys[] = "123A456B789C*0#DNF";  //  N = NoKey, F = Fail

  if (now - lastKeyPressed >= 500) {
    lastKeyPressed = now;

    start = micros();
    uint8_t index = keyPad.getKey();
    stop = micros();

    Serial.print(millis());
    Serial.print("\t");
    Serial.print(index);
    Serial.print("\t");
    Serial.print(keys[index]);
    Serial.print("\t");
    Serial.println(stop - start);
  }
}

sketch.ino

diagram.json

pcf8575

pcf8575.chip.json

#include "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>

#define I2C_BASE_ADDRESS 0x20
#define NUM_GPIO  16
#define NUM_ADDR_BITS  3

#define CHIPSTATE_FROM(usr_dat) chip_state_t * chip = (chip_state_t*)usr_dat
#define PRINTF_INPUTVALUE(msg, val)   printf("%s 0x%x (p0 0x%x, p1 0x%x)", msg, val, (val & 0xff), ((val & 0xff00) >> 8))

/* Chip state structure 
   Everything we care about and need access to in callbacks.
*/
typedef struct {
  // address bit pins and device address
  uint8_t address;
  pin_t addressBits[NUM_ADDR_BITS];

  // interrupt and "bidir" i/o pins
  pin_t nINT;
  pin_t io[NUM_GPIO];

  // input configuration and read value
  uint16_t inputMask;
  uint16_t inputValue;
  uint16_t lastReadValue;

  // i2c configuration, device and 
  // byte count/port count tracking
  i2c_dev_t i2c_dev;
  i2c_config_t i2c_config;
  uint8_t i2c_portcount;

  // our pin watch config for bidir 
  // io, so we can start/stop watching
  // depending on user settings writes
  pin_watch_config_t io_watch_config;

} chip_state_t;

/* Interrupt flag control 
  Note: inverted logic, i.e. when interrupt is asserted
  the open-drain output is a "switch" tied to ground.
  Otherwise, it is floating.
*/
void interruptFlagOff(chip_state_t* chip) {
  pin_mode(chip->nINT, INPUT);
}

void interruptFlagOn(chip_state_t* chip) {
  pin_mode(chip->nINT, OUTPUT_LOW);
  printf("INT flag SET\n");
}

/*
  All transactions are to be two-bytes long.
  Anything beyond this, in multiples of two, 
  simply restarts/overwrites, like a circular 
  buffer.
*/
void incrementPortCount(chip_state_t* chip) {
  if (chip->i2c_portcount) {
    // already 1, loop back to zero
    chip->i2c_portcount = 0;
  } else {
    chip->i2c_portcount = 1;
  }
}

/*
  I2C connection callback.
  Will tell up the device address and whether this is a read or write 
  operation
*/
bool on_i2c_connect(void *user_data, uint32_t address, bool read) {
  // `address` parameter contains the 7-bit address that was received on the I2C bus.
  // `read` indicates whether this is a read request (true) or write request (false).
  CHIPSTATE_FROM(user_data);

  if (address != chip->address) {
    printf("Getting connects for address 0x%x but am at 0x%x\n", address, chip->address);
    // return true;
  }

  // a new connection
  chip->i2c_portcount = 0;

  // printf("i2c connect for ");
  if (read) {
    printf("Read: reset INT flag\n");
    chip->lastReadValue = chip->inputValue;
    interruptFlagOff(chip);
  } 
  return true; // true means ACK, false NACK
}

/*
  Reading a port as a single byte.
*/
uint8_t on_i2c_read(void *user_data) {
  // printf("i2c Read\n");
  CHIPSTATE_FROM(user_data);
  uint8_t retVal = (chip->inputValue >> (chip->i2c_portcount*8)) & 0xff;
  
  incrementPortCount(chip);

  return retVal; // The byte to be returned to the microcontroller
}

/*
  Writing to a port configures the pins as either
   * output LOW
   * output HIGH / Input (with pull-up)
*/
bool on_i2c_write(void *user_data, uint8_t data) {
  // `data` is the byte received from the microcontroller
  CHIPSTATE_FROM(user_data);

  if (! chip->i2c_portcount) {
    // we are getting bytes, 
    // and this is the first of the 
    // two (or multiples of 2) ports.
    // so reset our input tracking mask
    chip->inputMask = 0;
  }

  for (uint8_t i=0; i<8; i++) {
    // we want our 16-bit index, calculated from 
    // both the bit of this particular byte and accounting
    // for if this is the first or second of the bytes written
    uint8_t bitIdx = i + (chip->i2c_portcount * 8);

    // shortcut to the i/o pin we're processing
    pin_t targetPin = chip->io[bitIdx];

    // disable any watch setup for this pin
    pin_watch_stop(targetPin);

    if (data & (1<<i)) {
      // this is a HIGH/read
      // note it in inputMask, setup up as input with pull-up and watch
      chip->inputMask |= (1 << bitIdx);
      pin_mode(targetPin, INPUT_PULLUP);
      pin_watch(targetPin, &(chip->io_watch_config));
    } else {
      
      // configured as output, tied to GND (low)
      pin_mode(targetPin, OUTPUT_LOW);
    }
  }

  if (chip->i2c_portcount) {
    // we just got the last of a set-of-two bytes
    printf("Input mask is now 0x%x\n", chip->inputMask);
  }

  // get ready for next byte written by incrementing port counter
  incrementPortCount(chip);

  return true; // true means ACK, false NACK
}

void on_i2c_disconnect(void *user_data) {
}

/*  I2C address management
  This is only available on start-up/init, so could in theory 
  simply be handled there.
*/
uint8_t read_address(chip_state_t* chip) {
  uint8_t configuredAddress = I2C_BASE_ADDRESS;
  uint8_t lsbits = 0;
  
  for (uint8_t i=0; i<NUM_ADDR_BITS; i++) {
    if (pin_read(chip->addressBits[i])) {
      lsbits |= (1 << i);
    }
  }

  configuredAddress = configuredAddress | lsbits;
  //printf("Chip LSB bits set to %i.  Address is 0x%02x\n", lsbits, configuredAddress);

  return configuredAddress;
}

void chip_addr_change(void *user_data, pin_t pin, uint32_t value) {
  CHIPSTATE_FROM(user_data);
  chip->address = read_address(chip);
}

/* 
  Read the value of the combined input pins, skipping over 
  any that have been configured as output (LOW)
*/
uint16_t readInputsValue(chip_state_t * chip) {
  uint16_t inputsValue = 0;
  for (uint8_t i=0; i<NUM_GPIO; i++) {
    if (chip->inputMask & (1 << i)) {
      // this is an input, we must read
      
      if (pin_read(chip->io[i])) {
          inputsValue |= (1<<i);
      }
    }
  }
  return inputsValue;
}

/*
  Anything that _may_ be treated as an output is watched and,
  on changes, this callback is triggered.
  If the value read in is different than that provided to user
  on last read, we will set the interrupt flag.
  If it is the same, we _clear_ the interrupt flag--this means
  that some changes may be missed by user... yap, but that's 
  how the chip works.
*/
void chip_input_io_change(void *user_data, pin_t pin, uint32_t value) {

  CHIPSTATE_FROM(user_data);
  
  chip->inputValue = readInputsValue(chip);

  if (chip->inputValue != chip->lastReadValue) {
    interruptFlagOn(chip);
  } else {
    interruptFlagOff(chip);
  }

  printf("I/O input changed:");
  PRINTF_INPUTVALUE("from", chip->lastReadValue);
  PRINTF_INPUTVALUE("to", chip->inputValue);
  printf("\n");
}

/*
  The chip_state_t structure is initialized here.
  Could do this in chip_init, but there are lots of values
  to set so this is separated out just for clarity.
*/
void initialize_state(chip_state_t * chip) {

  chip->address = I2C_BASE_ADDRESS;
  chip->inputMask = 0xffff;
  chip->inputValue = 0xffff;
  
  chip->i2c_portcount = 0;

  chip->io_watch_config.edge = BOTH;
  chip->io_watch_config.pin_change = chip_input_io_change;
  chip->io_watch_config.user_data = chip;


  i2c_config_t * i2c = &(chip->i2c_config);
  i2c->scl = pin_init("SCL", INPUT_PULLUP);
  i2c->sda = pin_init("SDA", INPUT_PULLUP);
  
  i2c->connect = on_i2c_connect;
  i2c->read = on_i2c_read;
  i2c->write = on_i2c_write;
  i2c->disconnect = on_i2c_disconnect;

  i2c->user_data = chip;
}

/*
  Chip initialization, called on startup.
*/
void chip_init() {
  chip_state_t *chip = malloc(sizeof(chip_state_t));
  const char * addrPinNames[] = {"A0", "A1", "A2"};
  const char * ioPinNames[] = {
        "P00", "P01", "P02", "P03", "P04", "P05", "P06", "P07",
        "P10", "P11", "P12", "P13", "P14", "P15", "P16", "P17"};

  // basic state setup 
  initialize_state(chip);
  chip->nINT = pin_init("nINT", INPUT);

  // address pins monitoring
  const pin_watch_config_t watch_addr_config = {
    .edge = BOTH,
    .pin_change = chip_addr_change,
    .user_data = chip,
  };

  for (uint8_t i=0; i<NUM_ADDR_BITS; i++) {
    chip->addressBits[i] = pin_init(addrPinNames[i], INPUT); 

    pin_watch(chip->addressBits[i], &watch_addr_config);
  }
  
  for (uint8_t i=0; i<NUM_GPIO; i++) {
    chip->io[i] = pin_init(ioPinNames[i], INPUT_PULLUP); // on power up, high/input
    pin_watch(chip->io[i], &(chip->io_watch_config));
  }
  chip->inputMask = 0xffff;

  chip->address = read_address(chip);
  chip->i2c_config.address = chip->address;
  chip->i2c_dev =  i2c_init(&(chip->i2c_config));

//  printf("I2C initialized @ address 0x%x\n", chip->address);

  interruptFlagOff(chip);
}

pcf8575.chip.c

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries
I2CKeyPad


libraries.txt

pcf8574

pcf8574.chip.json

// Wokwi Custom Chip - For docs and examples see:
// https://docs.wokwi.com/chips-api/getting-started
//
// SPDX-License-Identifier: MIT
// Copyright 2023 John Swartz
#include "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>

#define I2C_BASE_ADDRESS 0x20
#define NUM_GPIO 8
#define NUM_ADDR_BITS 3

#define CHIPSTATE_FROM(usr_dat) chip_state_t * chip = (chip_state_t*)usr_dat

typedef struct {
  uint8_t address;
  pin_t addressBits[NUM_ADDR_BITS];

  // interrupt and "bidir" i/o pins
  pin_t INT;
  pin_t io[NUM_GPIO];

  uint8_t inputMask; 
  uint8_t inputValue;
  uint8_t lastReadValue;

  i2c_dev_t i2c_dev;
  i2c_config_t i2c_config;

  pin_watch_config_t io_watch_config;
} chip_state_t;

// read the input values of the 9 io pins
uint8_t readInputValue(chip_state_t * chip) {
  uint8_t inputValue = 0;
  for (uint8_t i=0; i<NUM_GPIO; i++) {
    if (chip->inputMask & (1 << i)) {
      // this is an input, we must read
      if (pin_read(chip->io[i])) {
          inputValue |= (1<<i);
      }
    }
  }
  return inputValue;
}

void interruptFlagOff(chip_state_t* chip) {
  pin_mode(chip->INT, INPUT);
}

void interruptFlagOn(chip_state_t* chip) {
  pin_mode(chip->INT, OUTPUT_LOW);
}

void chip_input_io_change(void *user_data, pin_t pin, uint32_t value) {
  //printf("I/O input changed:");
  CHIPSTATE_FROM(user_data);
  
  chip->inputValue = readInputValue(chip);
  
  if (chip->inputValue != chip->lastReadValue)
    interruptFlagOn(chip);
  else
    interruptFlagOff(chip);
}


// read the i2c address from address pins
uint8_t read_address(chip_state_t* chip) {
  uint8_t configuredAddress = I2C_BASE_ADDRESS;
  uint8_t lsbits = 0;
  
  for (uint8_t i=0; i<NUM_ADDR_BITS; i++) {
    if (pin_read(chip->addressBits[i])) {
      lsbits |= (1 << i);
    }
  }
  configuredAddress = configuredAddress | lsbits;
  
  return configuredAddress;
}

// monitor chip address pins
void chip_addr_change(void *user_data, pin_t pin, uint32_t value) {
  CHIPSTATE_FROM(user_data);
  chip->address = read_address(chip);

  printf("I2C address is 0x%02x\n", chip->address);  
}

bool on_i2c_connect(void *user_data, uint32_t address, bool read) {
  CHIPSTATE_FROM(user_data);

  if (address != chip->address) {
    printf("Getting connects for address 0x%x but am at 0x%x\n", address, chip->address);
  }

  if (read) {
    printf("Read: reset INT flag\n");
    chip->lastReadValue = chip->inputValue;
    interruptFlagOff(chip);
  } 
  return true; // true means ACK, false NACK
}

uint8_t on_i2c_read(void *user_data) {
  CHIPSTATE_FROM(user_data);
  return chip->inputValue;
}

bool on_i2c_write(void *user_data, uint8_t data) {
  CHIPSTATE_FROM(user_data);

  chip->inputMask = 0;

  for (uint8_t i=0; i<8; i++) {
    pin_t targetPin = chip->io[i];
    // disable any watch setup for this pin
    pin_watch_stop(targetPin);

    if (data & (1<<i)) {
      // pin is input
      chip->inputMask |= (1 << i);
      pin_mode(targetPin, INPUT_PULLUP);
      pin_watch(targetPin, &(chip->io_watch_config));
    } else {
      // pin is output
      pin_mode(targetPin, OUTPUT_LOW);
    }
  }
  return true; // true means ACK, false NACK
}

void on_i2c_disconnect(void *user_data) {
}

void chip_init() {
  chip_state_t *chip = malloc(sizeof(chip_state_t));

  const char * addrPinNames[] = {"A0", "A1", "A2"};
  const char * ioPinNames[] = {"P0", "P1", "P2", "P3", "P4", "P5", "P6", "P7"};

  // chip config
  chip->address = I2C_BASE_ADDRESS;
  chip->inputMask = 0xff;
  chip->inputValue = 0xff;
  chip->io_watch_config.edge = BOTH;
  chip->io_watch_config.pin_change = chip_input_io_change;
  chip->io_watch_config.user_data = chip;

  // i2c config
  i2c_config_t * i2c = &(chip->i2c_config);
  i2c->scl = pin_init("SCL", INPUT_PULLUP);
  i2c->sda = pin_init("SDA", INPUT_PULLUP);
  i2c->connect = on_i2c_connect;
  i2c->read = on_i2c_read;
  i2c->write = on_i2c_write;
  i2c->disconnect = on_i2c_disconnect;
  i2c->user_data = chip;

  chip->INT = pin_init("INT", INPUT);

  // setup address pins
  const pin_watch_config_t watch_addr_config = {
    .edge = BOTH,
    .pin_change = chip_addr_change,
    .user_data = chip,
  };

  for (uint8_t i=0; i<NUM_ADDR_BITS; i++) {
    chip->addressBits[i] = pin_init(addrPinNames[i], INPUT); 
    pin_watch(chip->addressBits[i], &watch_addr_config);
  }  

  // setup io pins
  for (uint8_t i=0; i<NUM_GPIO; i++) {
    chip->io[i] = pin_init(ioPinNames[i], INPUT_PULLUP); // on power up, high/input
    pin_watch(chip->io[i], &(chip->io_watch_config));
  }
  chip->inputMask = 0xff;

  // get i2c address and init
  chip->address = read_address(chip);
  chip->i2c_config.address = chip->address;  
  chip->i2c_dev =  i2c_init(&(chip->i2c_config));
  printf("I2C initialized @ address 0x%x\n", chip->address);
}

