## MCH2022 Badge Hatchery Integration Template

Usage example:

https://wokwi.com/projects/337469004278923860?hatchery=citycontroltest_62d13fa94cd5c

README.md

// Wokwi Custom Chip - For information and examples see:
// https://link.wokwi.com/custom-chips-alpha
//
// SPDX-License-Identifier: MIT
// Copyright (C) 2022 Uri Shaked / wokwi.com

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

const int ADDRESS = 0x17;

enum {
    RP2040_REG_FW_VER = 0,
    RP2040_REG_GPIO_DIR,
    RP2040_REG_GPIO_IN,
    RP2040_REG_GPIO_OUT,
    RP2040_REG_LCD_BACKLIGHT,
    RP2040_REG_FPGA,
    RP2040_REG_INPUT1,
    RP2040_REG_INPUT2,
    RP2040_REG_INTERRUPT1,
    RP2040_REG_INTERRUPT2,
    RP2040_REG_ADC_TRIGGER,
    RP2040_REG_ADC_VALUE_VUSB_LO,
    RP2040_REG_ADC_VALUE_VUSB_HI,
    RP2040_REG_ADC_VALUE_VBAT_LO,
    RP2040_REG_ADC_VALUE_VBAT_HI,
    RP2040_REG_USB,
    RP2040_REG_BL_TRIGGER,
    RP2040_REG_WEBUSB_MODE,
    RP2040_REG_RESERVED1,
    RP2040_REG_RESERVED2,
    RP2040_REG_RESERVED3,
    RP2040_REG_CHARGING_STATE,
    RP2040_REG_ADC_VALUE_TEMP_LO,
    RP2040_REG_ADC_VALUE_TEMP_HI,
};

enum {
    RP2040_INPUT_BUTTON_HOME = 0,
    RP2040_INPUT_BUTTON_MENU,
    RP2040_INPUT_BUTTON_START,
    RP2040_INPUT_BUTTON_ACCEPT,
    RP2040_INPUT_BUTTON_BACK,
    RP2040_INPUT_FPGA_CDONE,
    RP2040_INPUT_BATTERY_CHARGING,
    RP2040_INPUT_BUTTON_SELECT,
    RP2040_INPUT_JOYSTICK_LEFT,
    RP2040_INPUT_JOYSTICK_PRESS,
    RP2040_INPUT_JOYSTICK_DOWN,
    RP2040_INPUT_JOYSTICK_UP,
    RP2040_INPUT_JOYSTICK_RIGHT,
};

DEFINE_PIN(VCC);
DEFINE_PIN(GND);
DEFINE_PIN(SCL);
DEFINE_PIN(SDA);
DEFINE_PIN(INT);
DEFINE_PIN(BTN_HOME);
DEFINE_PIN(BTN_MENU);
DEFINE_PIN(BTN_START);
DEFINE_PIN(BTN_ACCEPT);
DEFINE_PIN(BTN_BACK);
DEFINE_PIN(BTN_SELECT);
DEFINE_PIN(JOY_LEFT);
DEFINE_PIN(JOY_PRESS);
DEFINE_PIN(JOY_DOWN);
DEFINE_PIN(JOY_UP);
DEFINE_PIN(JOY_RIGHT);

typedef struct {
  /* GPIO pins */
  pin_t pin_int;
  pin_t pin_btn_home;
  pin_t pin_btn_menu;
  pin_t pin_btn_start;
  pin_t pin_btn_accept;
  pin_t pin_btn_back;
  pin_t pin_btn_select;
  pin_t pin_joy_left;
  pin_t pin_joy_press;
  pin_t pin_joy_down;
  pin_t pin_joy_up;
  pin_t pin_joy_right;

  /* I2C Interface state */
  bool write_reg_index;
  uint8_t reg_index;
  uint8_t input1;
  uint8_t input2;
  uint8_t interrupt1;
  uint8_t interrupt2;
  uint8_t reg_data[256];
} chip_state_t;

static void read_buttons(chip_state_t *chip);

static bool on_i2c_connect(void *chip, uint32_t address, bool connect);
static uint8_t on_i2c_read(void *chip);
static bool on_i2c_write(void *chip, uint8_t data);

void* chip_init() {
  setvbuf(stdout, NULL, _IOLBF, 1024); // Disable buffering for debug logs

  chip_state_t *chip = malloc(sizeof(chip_state_t));

  memset(chip, 0, sizeof(chip_state_t));
  chip->pin_int = pin_init("INT", INPUT_PULLUP);
  chip->pin_btn_home = pin_init("BTN_HOME", INPUT_PULLUP);
  chip->pin_btn_menu = pin_init("BTN_MENU", INPUT_PULLUP);
  chip->pin_btn_start = pin_init("BTN_START", INPUT_PULLUP);
  chip->pin_btn_accept = pin_init("BTN_ACCEPT", INPUT_PULLUP);
  chip->pin_btn_back = pin_init("BTN_BACK", INPUT_PULLUP);
  chip->pin_btn_select = pin_init("BTN_SELECT", INPUT_PULLUP);
  chip->pin_joy_left = pin_init("JOY_LEFT", INPUT_PULLUP);
  chip->pin_joy_press = pin_init("JOY_PRESS", INPUT_PULLUP);
  chip->pin_joy_down = pin_init("JOY_DOWN", INPUT_PULLUP);
  chip->pin_joy_up = pin_init("JOY_UP", INPUT_PULLUP);
  chip->pin_joy_right = pin_init("JOY_RIGHT", INPUT_PULLUP);

  pin_watch(chip->pin_btn_home, BOTH);
  pin_watch(chip->pin_btn_menu, BOTH);
  pin_watch(chip->pin_btn_start, BOTH);
  pin_watch(chip->pin_btn_accept, BOTH);
  pin_watch(chip->pin_btn_back, BOTH);
  pin_watch(chip->pin_btn_select, BOTH);
  pin_watch(chip->pin_joy_left, BOTH);
  pin_watch(chip->pin_joy_press, BOTH);
  pin_watch(chip->pin_joy_down, BOTH);
  pin_watch(chip->pin_joy_up, BOTH);
  pin_watch(chip->pin_joy_right, BOTH);


  const i2c_dev_t i2c_dev = {
    .address = ADDRESS,
    .scl = pin_init("SCL", INPUT),
    .sda = pin_init("SDA", INPUT),
    .connect = on_i2c_connect,
    .read = on_i2c_read,
    .write = on_i2c_write,
  };
  i2c_init(chip, &i2c_dev);
  chip->reg_index = 0;

  // The following message will appear in the browser's DevTools console:
  printf("Hello from custom chip!\n");

  // Returning the chip instance is going away soon - but is still needed for some APIs (SPI, timers, pin_watch)
  return chip;
}

static void read_buttons(chip_state_t *chip) {
  const uint8_t input1 = 
    (pin_read(chip->pin_btn_home) ? 0 : (1 << RP2040_INPUT_BUTTON_HOME)) |
    (pin_read(chip->pin_btn_menu) ? 0 : (1 << RP2040_INPUT_BUTTON_MENU)) |
    (pin_read(chip->pin_btn_start) ? 0 : (1 << RP2040_INPUT_BUTTON_START)) |
    (pin_read(chip->pin_btn_accept) ? 0 : (1 << RP2040_INPUT_BUTTON_ACCEPT)) |
    (pin_read(chip->pin_btn_back) ? 0 : (1 << RP2040_INPUT_BUTTON_BACK)) |
    (pin_read(chip->pin_btn_select) ? 0 : (1 << RP2040_INPUT_BUTTON_SELECT));
  const uint8_t input2 = 
    (pin_read(chip->pin_joy_left) ? 0 : (1 << (RP2040_INPUT_JOYSTICK_LEFT - 8))) |
    (pin_read(chip->pin_joy_press) ? 0 : (1 << (RP2040_INPUT_JOYSTICK_PRESS - 8))) |
    (pin_read(chip->pin_joy_down) ? 0 : (1 << (RP2040_INPUT_JOYSTICK_DOWN - 8))) |
    (pin_read(chip->pin_joy_up) ? 0 : (1 << (RP2040_INPUT_JOYSTICK_UP - 8))) |
    (pin_read(chip->pin_joy_right) ? 0 : (1 << (RP2040_INPUT_JOYSTICK_RIGHT - 8)));
  chip->interrupt1 |= input1 ^ chip->input1;
  chip->input1 = input1;
  chip->interrupt2 |= input2 ^ chip->input2;
  chip->input2 = input2;
  if (chip->interrupt1 || chip->interrupt2) {
    pin_mode(chip->pin_int, OUTPUT_LOW);
  }
}

void EXPORT(chip_pin_change)(chip_state_t *chip, pin_t pin, uint32_t value) {
  read_buttons(chip);
}


static uint8_t reg_read(chip_state_t *chip, uint8_t reg) {
  switch (reg) {
    case RP2040_REG_FW_VER:
      return 0xf0;

    case RP2040_REG_INPUT1:
      return chip->input1;

    case RP2040_REG_INPUT2:
      return chip->input2;

    case RP2040_REG_INTERRUPT1:
      return chip->interrupt1;

    case RP2040_REG_INTERRUPT2: {
      const uint8_t result = chip->interrupt2;
      chip->interrupt1 = 0;
      chip->interrupt2 = 0;
      pin_mode(chip->pin_int, INPUT_PULLUP);
      return result;
    }

    default:
      return chip->reg_data[reg];
  }
}

static void reg_write(chip_state_t *chip, uint8_t reg, uint8_t value) {
  switch (reg) {
    default:
      chip->reg_data[reg] = value;
  }
}

bool on_i2c_connect(void *user_ctx, uint32_t address, bool connect) {
  chip_state_t *chip = user_ctx;
  chip->write_reg_index = true;
  return true; /* Ack */
}

uint8_t on_i2c_read(void *user_ctx) {
  chip_state_t *chip = user_ctx;
  // printf("I2C Read register: %d\n", chip->reg_index);
  return reg_read(chip, chip->reg_index++);
}

bool on_i2c_write(void *user_ctx, uint8_t data) {
  chip_state_t *chip = user_ctx;
  if (chip->write_reg_index) {
    chip->reg_index = data;
    chip->write_reg_index = false;
  } else {
    reg_write(chip, chip->reg_index, data);
    chip->reg_index++;
  }
  return true; // Ack
}
