#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Set the LCD address to 0x27 for a 16x2 display
LiquidCrystal_I2C lcd(0x27, 16, 2);

// I2C things.
byte i2c_rcv;

// List o things
enum {
  DEV_CMD_INIT = 0x01,
  DEV_STATUS_ACK,
  DEV_STATUS_NACK
};

// I2C device.
typedef struct {
  int address;
  bool ready;
  char* name;
} i2c_device;

i2c_device devList[] = {
  (i2c_device){0x22, false, "LED Status Chip"}
};

// Init and connect.
bool initializeSystem() {
  // Loop through and init devices.
  for(int i=0; i<sizeof(devList); i++) {
    lcd.clear();
    Wire.beginTransmission(devList[i].address);
    Wire.write(DEV_CMD_INIT);
    Wire.endTransmission();

    Wire.requestFrom(devList[i].address, 1); // Read 1 byte
    if(Wire.available()) {
      i2c_rcv = Wire.read();
    }
    
    // Handle device init.
    switch(i2c_rcv) {
      case DEV_STATUS_ACK:
        lcd.print(devList[i].name);
        break;
      case DEV_STATUS_NACK:
        lcd.print("Nope no sir");
        break;
    }
  }
}

void setup() {
  Wire.begin();

  // Init 16x2
  lcd.begin(16, 2);

  // Turn on the BL
  lcd.setBacklight(HIGH);

  // Init message
  lcd.print("Initialize");

  // Init
  initializeSystem();
}

void loop() {
  // put your main code here, to run repeatedly:

}


sketch.ino

diagram.json

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

I2C
LiquidCrystal I2C


libraries.txt

led-interface

led-interface.chip.json

// Wokwi Custom Chip - For docs and examples see:
// https://docs.wokwi.com/chips-api/getting-started
//
// SPDX-License-Identifier: MIT
// Copyright 2023 larry parry

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

typedef struct {
  // TODO: Put your chip variables here
  i2c_dev_t i2cdevice;
  uint8_t lastRecvByte;

  // Timers.
  timer_t nodataTimer;

  // Misc GPIO.
  pin_t linkLight;
  pin_t dataLight;
} chip_state_t;

// Chip.
chip_state_t *chip;

// List o things
enum {
  DEV_CMD_INIT = 0x01,
  DEV_STATUS_ACK,
  DEV_STATUS_NACK
};

// Timer callbacks.
void noDataCallback(void *user_data) {
  pin_write(chip->dataLight, LOW);
}

// Handle read.
uint8_t handleRead(uint8_t CMD) {
  switch(CMD) {
    case DEV_CMD_INIT:
      pin_write(chip->linkLight, HIGH);
      return DEV_STATUS_ACK;
  }
  return DEV_STATUS_NACK;
}

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).
  pin_write(chip->dataLight, HIGH);
  printf("Address 0x%08x and 0x%01x\n", address, read);
  return true; // true means ACK, false NACK
}

uint8_t on_i2c_read(void *user_data) {
  printf("My man wants to read\n");
  return handleRead(chip->lastRecvByte); // The byte to be returned to the microcontroller
}

bool on_i2c_write(void *user_data, uint8_t data) {
  // `data` is the byte received from the microcontroller
  printf("Recv: 0x%02x\n", data);
  chip->lastRecvByte = data;
  return true; // true means ACK, false NACK
}

void on_i2c_disconnect(void *user_data) {
  // This method is optional. Useful if you need to know when the I2C transaction has concluded.
}

void chip_init() {
  // Chip memory.
  chip = malloc(sizeof(chip_state_t));

  // Init normal GPIO.
  chip->linkLight = pin_init("LNK", OUTPUT_LOW); // Link light
  chip->dataLight = pin_init("RCV", OUTPUT_LOW); // Data light

  // I2C config.
  const i2c_config_t i2c1 = {
    .address = 0x22,
    .scl = pin_init("SCL", INPUT_PULLUP),
    .sda = pin_init("SDA", INPUT_PULLUP),
    .connect = on_i2c_connect,
    .read = on_i2c_read,
    .write = on_i2c_write,
    .disconnect = on_i2c_disconnect,
    .user_data = chip
  };
  
  // Data light off timer.
  const timer_config_t dltConf = {
    .callback = noDataCallback,
    .user_data = chip
  };

  // Timer init
  chip->nodataTimer = 

  // I2C Init.
  chip->i2cdevice = i2c_init(&i2c1);
}
