#include <SPI.h>

#define LCD_CS 2
#define LCD_DC 3

void setup() {
  // put your setup code here, to run once:
  SPI.begin();

  // Set CS
  pinMode(LCD_CS, OUTPUT);
  pinMode(LCD_DC, OUTPUT);

  // No Select
  digitalWrite(LCD_CS, HIGH);
  digitalWrite(LCD_DC, HIGH);
}

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

}


sketch.ino

diagram.json

dtn69420lcd

dtn69420lcd.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>
#include <string.h>

// Debug Chip Mode
#define DEBUG

// State enum
enum {
  DATAMODE_READ,
  DATAMODE_WRITE
};

// Commands
#define LCD_CMD_INIT  0x10  // Init Display
#define LCD_CMD_MODE  0x11  // Mode (Single or Array)
#define LCD_CMD_WRITE 0x12  // Write Data
#define LCD_CMD_READ  0x13  // Read Data
#define LCD_CMD_SBUF  0x14  // Swap Buffer

// RGBA Structure
typedef struct {
  uint8_t r;
  uint8_t g;
  uint8_t b;
  uint8_t a;
} rgba_t;

// Double Buffering
rgba_t *xfb1;
rgba_t *xfb2;

// Chip States and Settings
typedef struct {
  /* Pins */
  pin_t    cs_pin;  // Chip Select
  pin_t    dc_pin;  // Data Control

  /* Interface SPI */
  uint32_t spi;
  uint8_t  spi_buffer[1];

  /* Display */
  buffer_t xfb;
  size_t xfbSize;
  uint32_t width;
  uint32_t height;

  /* States */
  bool csState; // Chip Select State.
  int cBuffer;  // Current Buffer
  int dataMode; // Data Mode
} chip_state_t;

// Forwarding functions
static void on_chipSelect(void *user_data, pin_t pin, uint32_t value);
static void on_dataControl(void *user_data, pin_t pin, uint32_t value);
static void on_spi_done(void *user_data, uint8_t *buffer, uint32_t count);

// Forwarding functions (Drawing)
rgba_t rgba2RGBT(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
rgba_t uint32toRGBAT(uint32_t c);

void drawCBuffer(void *user_data);
void fillBuffer(void* user_data, rgba_t color);

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

  // Setup Pins
  chip->cs_pin = pin_init("CS", INPUT_PULLUP);
  chip->dc_pin = pin_init("DC", INPUT_PULLUP);

  // Pin Watchers
  const pin_watch_config_t on_chipselect_watcher = {
    .edge = BOTH,
    .pin_change = on_chipSelect,
    .user_data = chip,
  }; const pin_watch_config_t on_datacontrol_watcher = {
    .edge = BOTH,
    .pin_change = on_dataControl,
    .user_data = chip,
  };

  // SPI Interface Configuration
  const spi_config_t spi_config = {
    .sck = pin_init("SCK", INPUT),
    .miso = pin_init("MISO", INPUT),
    .mosi = pin_init("MOSI", INPUT),
    .done = on_spi_done,
    .user_data = chip,
  };

  // Use the Watchers.
  pin_watch(chip->cs_pin, &on_chipselect_watcher);
  pin_watch(chip->dc_pin, &on_datacontrol_watcher);

  //printf("%s", lib);

  // Use the interfaces.
  chip->spi = spi_init(&spi_config);
  chip->xfb = framebuffer_init(&chip->width, &chip->height);

  #ifdef DEBUG
  printf("%s(): %ux%u XFB\n", __FUNCTION__, chip->width, chip->height);
  #endif

  // Setup for Double Buffering
  chip->xfbSize = ((chip->width*chip->height)*sizeof(rgba_t));
  xfb1 = (rgba_t*)malloc(chip->xfbSize);
  xfb2 = (rgba_t*)malloc(chip->xfbSize);
  memset(&xfb1, 0, chip->xfbSize);
  memset(&xfb2, 0, chip->xfbSize);
  chip->cBuffer = 0;

  // Thing
  //printf("Main at 0x%08x.\n", &start);

  // Error handler
  if(xfb1 == NULL || xfb2 == NULL) {
    printf("%s(): ERROR: XFB1:%s, XFB2:%s\n", __FUNCTION__, ((xfb1 == NULL) ? "FAIL":"OK"),((xfb2 == NULL) ? "FAIL":"OK"));
    return;
  }
  
  // Clear White
  fillBuffer((void*)chip, rgba2RGBT(255,255,255,255));
  drawCBuffer((void*)chip);

  // Howdy mate
  printf("Hello from custom chip!\n");
}

/* Drawing */

// RGBA Seperate to RGBA_T
rgba_t rgba2RGBT(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
{
  rgba_t ret = (rgba_t){.r=r, .g=g, .b=b, .a=a};
  return ret;
}

// Single UINT32_T to RGBA_T
rgba_t uint32toRGBAT(uint32_t c)
{
  rgba_t ret = {.r=(c>>16)&0xff, .g=(c>>8)&0xff, .b=(c)&0xff, .a=0xff};
  return ret;
}

// XY to Uint32_t
uint32_t pos2Offset(void *user_data, uint32_t x, uint32_t y) {
    chip_state_t *chip = (chip_state_t*)user_data;

    if (x >= chip->width || y >= chip->height) {
        return 0; // Make sure the (x, y) coordinates are within the framebuffer's bounds
    }

    // Calculate the offset in bytes for the pixel (x, y)
    uint32_t offset = (y * chip->width*4 + x*4);

    // Return Offset.
    return offset;
}

rgba_t** getXfb(void *user_data) {
  chip_state_t *chip = (chip_state_t*)user_data;
  return (chip->cBuffer == 0) ? &xfb1 : &xfb2;
}

// Draw cBuffer
void drawCBuffer(void *user_data) {
  chip_state_t *chip = (chip_state_t*)user_data;
  rgba_t *cBuf = (rgba_t*)getXfb(user_data);
  for(int y=0; y<chip->height; y++) {
    for(int x=0; x<chip->width; x++) {
      uint32_t pos = pos2Offset(user_data, x,y);
      buffer_write(chip->xfb, pos, &cBuf[pos], sizeof(rgba_t));
    }
  }
}

// Fill Screen
void fillBuffer(void* user_data, rgba_t color) {
  chip_state_t *chip = (chip_state_t*)user_data;
  rgba_t *cBuf = (rgba_t*)getXfb(user_data);
  for(int y=0; y<chip->height; y++) {
    for(int x=0; x<chip->width; x++) {
      uint32_t pos = pos2Offset(user_data, x,y);
      cBuf[pos] = color;
    }
  }
}

/*
  SPI Interface
*/

// Chip Select Pin Changed
void on_chipSelect(void *user_data, pin_t pin, uint32_t value) {
  chip_state_t *chip = (chip_state_t*)user_data;

  // Debug, if any
  #ifdef DEBUG
  printf("%s(): Value do be set to %u\n", __FUNCTION__, value);
  #endif

  if (pin == chip->cs_pin) {
    if(value == LOW) {
      #ifdef DEBUG
      printf("%s(): SPI Listening...\n", __FUNCTION__);
      #endif
      spi_start(chip->spi, chip->spi_buffer, sizeof(chip->spi_buffer));
    } else {
      #ifdef DEBUG
      printf("%s(): SPI Done Listening.\n", __FUNCTION__);
      #endif
      spi_stop(chip->spi);
    }
  }
}

// Data Control Pin Changed
void on_dataControl(void *user_data, pin_t pin, uint32_t value) {
  chip_state_t *chip = (chip_state_t*)user_data;

  // Debug, if any
  #ifdef DEBUG
  printf("%s(): Value do be set to %u\n", __FUNCTION__, value);
  #endif

  if (pin == chip->dc_pin) {
    if(value == LOW) {
      chip->dataMode = DATAMODE_READ;
      #ifdef DEBUG
      printf("%s(): Data mode is %s.\n", __FUNCTION__, chip->dataMode ? "WRITE" : "READ");
      #endif
    } else {
      chip->dataMode = DATAMODE_WRITE;
      #ifdef DEBUG
      printf("%s(): Data mode is %s.\n", __FUNCTION__, chip->dataMode ? "WRITE" : "READ");
      #endif
    }
  }
}

// Called when SPI receive buffer full
void on_spi_done(void *user_data, uint8_t *buffer, uint32_t count) {
  #ifdef DEBUG
  printf("%s(): Just snorted %uB of SPI data\n", __FUNCTION__, count);
  #endif
}