#include <Adafruit_GFX.h>
#include <SPI.h>
#include "gfx.hpp"

// Pin definition
#define RAM_CS     47

#define TFT_CS     53
#define TFT_RESET  49
#define TFT_DC     48

#define TFT2_CS     45
#define TFT2_RESET  44
#define TFT2_DC     43

void setup() {
  // Start serial communication for debugging
  Serial.begin(9600);

  // Dakotath GFX
  GFXRenderer renderer(TFT_CS, TFT_DC, TFT_RESET);
  GFXRenderer renderer2(TFT2_CS, TFT2_DC, TFT2_RESET);

  // Draw 32 random color rectangles at random positions
  for (int i = 0; i < 32; i++) {
    // Random position on the screen (x, y)
    int x = random(0, renderer.width() - 50);  // Ensure rectangle fits within screen width
    int y = random(0, renderer.height() - 50);  // Ensure rectangle fits within screen height

    // Random size for the rectangle (width, height)
    int width = random(20, 100);  // Width between 20 and 100 pixels
    int height = random(20, 100);  // Height between 20 and 100 pixels

    // Random color (16-bit)
    uint16_t color = random(0x0000, 0xFFFF);  // Generate random color

    // Create a GFXRectangle object with the random properties
    GFXRectangle rect(x, y, width, height, color);

    // Draw the rectangle
    renderer.GFXDrawShape(rect);
  }
}

void loop() {
  // Nothing to do here as we just want to fill the screen once
}


sketch.ino

diagram.json

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

Adafruit ILI9341
Adafruit GFX Library
SRAM_23LC
TFT
Adafruit ST7735 and ST7789 Library


libraries.txt

// GFX.cpp - (C)2024 Dakota Thorpe.

// Includes
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>
#include "gfxrenderer.hpp"
#include "gfx.hpp"

// Constructor accepts pin numbers for CS, DC, RESET
GFXRenderer::GFXRenderer(int CS, int DC, int RESET)
  : tft(CS, DC, RESET) {  // Initialize the tft object using the constructor's initializer list
  // Alert and init.
  Serial.println(F("Dakotath GFX Library Starting..."));

  // Initialize the TFT display
  tft.begin();

  // Set the rotation of the screen (optional)
  //tft.setRotation(3);  // 0, 1, 2, or 3 depending on how your screen is oriented

  // Fill the screen with the color #8888FF (RGB 136, 136, 255)
  //tft.fillScreen(tft.color565(136, 136, 255));

  // Get the display size
  rendWidth = tft.width();
  rendHeight = tft.height();

  // Init Complete, create init message.
  char* initMsg = (char*)malloc(64);
  sprintf(initMsg, "DGFX: Display is %dx%d", rendWidth, rendHeight);
  Serial.println(initMsg);
  free(initMsg);
}
GFXRenderer::~GFXRenderer() {
  Serial.println(F("Dakotath GFX Library done."));
}

// Shape Draw
void GFXRenderer::GFXDrawShape(GFXShape& shape) {
  shape.draw(tft);
}

void GFXRenderer::GFXDrawText(GFXText& textObj) {
  // First, compute the bounds for the text
  textObj.computeBounds(*this);
  
  // Now, draw the text using the properties of the GFXText object
  tft.setTextSize(textObj.size);     // Set the font size
  tft.setTextColor(textObj.color);   // Set the text color
  tft.setCursor(textObj.x, textObj.y); // Set the cursor position
  tft.print(textObj.text);           // Print the text
}

gfx.cpp

// Dakotath Graphics Header
#ifndef GFX_HPP
#define GFX_HPP

// ILI9341
#include <Adafruit_ILI9341.h>
#include <Adafruit_GFX.h>

// Class Forwarding
#include "gfxrenderer.hpp"

// Error Types
enum {
  GFXLIB_ERROR_OK,
  GFXLIB_ERROR_INIT
};

// GFXObject Class
class GFXObject {
  public:
    int x, y;
    int width, height;
    uint16_t color;  // Color of the object

    // Constructor to initialize position and size
    GFXObject(int x, int y, int width, int height) {
      this->x = x;
      this->y = y;
      this->width = width;
      this->height = height;
    }

    // Set position of the object
    void setPosition(int x, int y) {
      this->x = x;
      this->y = y;
    }

    // Set size of the object
    void setSize(int width, int height) {
      this->width = width;
      this->height = height;
    }

    // Get position
    void getPosition(int& x, int& y) {
      x = this->x;
      y = this->y;
    }

    // Get size
    void getSize(int& width, int& height) {
      width = this->width;
      height = this->height;
    }

    // Check if a point (px, py) is inside the object
    bool isPointInside(int px, int py) {
      return (px >= x && px <= x + width) && (py >= y && py <= y + height);
    }

    // Set the color of the shape
    void setColor(uint16_t newColor) {
      color = newColor;
    }

    // Get the color of the shape
    uint16_t getColor() const {
      return color;
    }

    // Virtual destructor to allow polymorphism
    virtual ~GFXObject() {}
};

// GFX Shape
class GFXShape : public GFXObject {
  public:
    // Constructor
    GFXShape(int x, int y, int width, int height, uint16_t shapeColor) : GFXObject(x, y, width, height) {
      color = shapeColor;
    }
    virtual ~GFXShape() {}

    // Virtual method to draw the shape, will be overridden in derived classes
    virtual void draw(Adafruit_ILI9341& tft) = 0;
};

// GFXRectangle Class (Derived class for rectangles)
class GFXRectangle : public GFXShape {
  public:
    // Constructor to initialize position, size, and color
    GFXRectangle(int x, int y, int width, int height, uint16_t color)
      : GFXShape(x, y, width, height, color) {}

    // Override the draw method to draw a filled rectangle on the TFT screen
    void draw(Adafruit_ILI9341& tft) override;
};

// GFXText Class
class GFXText : public GFXObject {
  public:
    uint8_t size;   // Font Size (0-256).
    char* text;     // Text object Text.

    // Constructor - Now requires a reference to a GFXRenderer object
    GFXText(GFXRenderer& renderer, const char* txt, uint8_t fntSize, uint16_t txtColor)
      : GFXObject(0, 0, 0, 0), size(fntSize) {
      
      // Set up text settings
      color = txtColor;

      // Allocate memory and copy the text
      int len = strlen(txt) + 1;
      text = new char[len];
      strcpy(text, txt);

      // Use Adafruit_GFX method to determine the text bounds via the renderer's tft object
      int16_t x1, y1;
      uint16_t w, h;

      // Get the text bounds using the tft instance from the renderer
      renderer.getTFT().getTextBounds(text, 0, 0, x1, y1, w, h);

      // Set the width and height of the text object based on the text bounds
      this->width = w;
      this->height = h;
    }

    // Destructor to free the allocated memory for the text
    ~GFXText() {
      delete[] text; // Release the memory allocated for the text
    }

    // Function to set the size of the text based on the renderer
    void computeBounds(GFXRenderer& renderer) {
      int16_t x1, y1;
      uint16_t w, h;
      
      // Get the text bounds using the tft instance from the renderer
      renderer.getTFT().getTextBounds(text, 0, 0, x1, y1, w, h);
      
      // Set the width and height of the text object based on the text bounds
      this->width = w;
      this->height = h;
    }
};

#endif // GFX_HPP

gfx.hpp

// GFXShapes.cpp - (C)2024 Dakota Thorpe.
#include "gfx.hpp"

// GFXRectangle
void GFXRectangle::draw(Adafruit_ILI9341& tft) {
  tft.fillRect(x, y, width, height, color);  // Draw the rectangle
}

gfxshapes.cpp

sram

sram.chip.json

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

#define MEMORY_SIZE 0x200000  // 64KB of SRAM (addressable range 0-65535)
#define MEMORY_BLOCK_SIZE 8  // 64-bit = 8 bytes

#define SRAM_MODE_WRITE true
#define SRAM_MODE_READ  false

typedef struct {
    pin_t    cs_pin;         // Chip select pin
    pin_t    rw_pin;         // Read Write Operation pin
    bool     mode;
    uint32_t spi;            // SPI instance
    uint8_t  spi_buffer[16]; // SPI buffer (address + 8 bytes data)
    uint8_t  memory[MEMORY_SIZE * MEMORY_BLOCK_SIZE]; // Memory to simulate SRAM (64-bit per address)
    uint64_t address;        // Current address to read/write
    uint8_t  operation;      // Operation: 0 = read, 1 = write
} chip_state_t;

// Function prototypes
static void chip_pin_change(void *user_data, pin_t pin, uint32_t value);
static void chip_rw_change(void *user_data, pin_t pin, uint32_t value);
static void chip_spi_done(void *user_data, uint8_t *buffer, uint32_t count);

void chip_init(void) {
    chip_state_t *chip = malloc(sizeof(chip_state_t));
    
    chip->cs_pin = pin_init("CS", INPUT_PULLUP);
    chip->rw_pin = pin_init("RW", INPUT_PULLUP);
    chip->address = 0x0000; // Start address
    chip->operation = 1;    // Default to write operation

    // Set up pin watcher for CS pin
    const pin_watch_config_t watch_config = {
        .edge = BOTH,
        .pin_change = chip_pin_change,
        .user_data = chip,
    };
    const pin_watch_config_t watch_rw_config = {
        .edge = BOTH,
        .pin_change = chip_rw_change,
        .user_data = chip,
    };
    pin_watch(chip->cs_pin, &watch_config);
    pin_watch(chip->rw_pin, &watch_rw_config);

    // SPI configuration
    const spi_config_t spi_config = {
        .sck = pin_init("SCK", INPUT),
        .miso = pin_init("MISO", INPUT),
        .mosi = pin_init("MOSI", INPUT),
        .done = chip_spi_done,
        .user_data = chip,
    };
    chip->spi = spi_init(&spi_config);
    
    printf("SPI Chip initialized!\n");

    // Initialize memory to zero
    memset(chip->memory, 0, sizeof(chip->memory));
}

// Function to handle CS pin change (Chip Select)
void chip_pin_change(void *user_data, pin_t pin, uint32_t value) {
    chip_state_t *chip = (chip_state_t*)user_data;
    
    if (pin == chip->cs_pin) {
        if (value == LOW) {  // Chip is selected
            //printf("SPI chip selected\n");
            // Start reading/writing based on operation
            spi_start(chip->spi, chip->spi_buffer, sizeof(chip->spi_buffer));
        } else {  // Chip is deselected
            //printf("SPI chip deselected\n");
            spi_stop(chip->spi);
        }
    }
}

// Function to handle RW pin change (Read Write)
void chip_rw_change(void *user_data, pin_t pin, uint32_t value) {
    chip_state_t *chip = (chip_state_t*)user_data;
    
    if (pin == chip->rw_pin) {
        if (value == LOW) {  // Chip is selected
            printf("Write Mode Set\n");
            // Start reading/writing based on operation
            chip->mode = SRAM_MODE_WRITE;
        } else {  // Chip is deselected
            printf("Read Mode Set\n");
            chip->mode = SRAM_MODE_READ;
        }
    }
}

// SPI transfer done handler
void chip_spi_done(void *user_data, uint8_t *buffer, uint32_t count) {
    chip_state_t *chip = (chip_state_t*)user_data;

    //printf("Data Count: %u\n", count);
    if (count == 0) {
        // No data received, so stop
        return;
    }

    // Extract the address (first 8 bytes for 64-bit addressing)
    uint64_t address = 0;
    for (int i = 0; i < 8; i++) {
        address |= ((uint64_t)buffer[i] << ((7 - i) * 8));
    }

    // Read operation: fetch data from memory
    if (pin_read(chip->cs_pin) == LOW) {
        if (chip->mode == SRAM_MODE_WRITE) {
            // Write Operation (store data in memory)
            for (int i = 0; i < MEMORY_BLOCK_SIZE; i++) {
                chip->memory[(address * MEMORY_BLOCK_SIZE) + i] = buffer[8 + i];
            }
            //printf("Wrote 64-bit data to address 0x%016llX\n", address);
        } else if (chip->mode == SRAM_MODE_READ) {
            // Read Operation (retrieve data from memory)
            for (int i = 0; i < MEMORY_BLOCK_SIZE; i++) {
                chip->spi_buffer[8 + i] = chip->memory[(address * MEMORY_BLOCK_SIZE) + i];
            }
            //printf("Read 64-bit data from address 0x%016llX\n", address);
        }
        
        // Flip operation for next transaction
        chip->operation = (chip->operation == 1) ? 0 : 1; // Toggle between write and read

        // Start the next SPI transaction (either reading or writing)
        spi_start(chip->spi, chip->spi_buffer, sizeof(chip->spi_buffer));
    }
}


sram.chip.c

#include <SPI.h>
#include "SRAM64.h"

// Constructor to initialize the chip select pin
SRAM64::SRAM64(int csPin, int rwPin) {
    _csPin = csPin;
    _rwPin = rwPin;
    pinMode(_csPin, OUTPUT);
    pinMode(_rwPin, OUTPUT);
    digitalWrite(_csPin, HIGH);   // Deselect the chip initially
    setMode(SRAM_MODE_WRITE);     // Write Mode
    SPI.begin();
}

// Function to select the mode of command
void SRAM64::setMode(bool isWrite) {
  if(isWrite) {
    digitalWrite(_rwPin, HIGH);
  } else {
    digitalWrite(_rwPin, LOW);
  }
}

// Function to select the chip by pulling the CS pin low
void SRAM64::selectChip() {
    digitalWrite(_csPin, LOW);  // Set the chip select pin low to select the chip
}

// Function to deselect the chip by pulling the CS pin high
void SRAM64::deselectChip() {
    digitalWrite(_csPin, HIGH);  // Set the chip select pin high to deselect the chip
}

void SRAM64::sendAddress(uint64_t adr) {
    for (int i = 7; i >= 0; i--) {
        SPI.transfer((adr >> (i * 8)) & 0xFF);  // Send the address byte by byte
    }
}

void SRAM64::writeByte(uint64_t adr, byte data) {
    setMode(SRAM_MODE_WRITE);
    selectChip();
    sendAddress(adr);  // Send the 64-bit address
    SPI.transfer(data);  // Send the byte of data
    for(int i=0; i<7; i++) {
      SPI.transfer(0); // Remaining data
    }
    deselectChip();
}

byte SRAM64::readByte(uint64_t adr) {
    byte receivedData = 0;
    setMode(SRAM_MODE_READ);
    selectChip();
    sendAddress(adr);  // Send the 64-bit address
    receivedData = SPI.transfer(0);  // Read the byte of data
    for(int i=0; i<7; i++) {
      SPI.transfer(0); // Remaining data
    }
    deselectChip();
    return receivedData;
}

void SRAM64::writeInt(uint64_t adr, uint64_t data) {
    selectChip();
    setMode(SRAM_MODE_WRITE);
    sendAddress(adr);  // Send the 64-bit address
    for (int i = 7; i >= 0; i--) {
        SPI.transfer((data >> (i * 8)) & 0xFF);  // Send the integer byte by byte
    }
    deselectChip();
}

uint64_t SRAM64::readInt(uint64_t adr) {
    uint64_t receivedData = 0;
    selectChip();
    setMode(SRAM_MODE_READ);
    sendAddress(adr);  // Send the 64-bit address
    for (int i = 7; i >= 0; i--) {
        receivedData |= (uint64_t)SPI.transfer(0) << (i * 8);  // Read the integer byte by byte
    }
    deselectChip();
    return receivedData;
}

// Write an array of bytes starting at a specific address
void SRAM64::writeByteArray(uint64_t beginAdr, byte* data, size_t dataCount) {
    for (size_t i = 0; i < dataCount; i++) {
        writeByte(beginAdr+i, data[i]);  // Write each byte in the array
    }
}

// Write an array of 64-bit integers starting at a specific address
void SRAM64::writeIntArray(uint64_t beginAdr, uint64_t* data, size_t dataCount) {
    selectChip();
    sendAddress(beginAdr);  // Send the 64-bit address
    for (size_t i = 0; i < dataCount; i++) {
        for (int j = 7; j >= 0; j--) {
            SPI.transfer((data[i] >> (j * 8)) & 0xFF);  // Send each 64-bit integer byte by byte
        }
    }
    deselectChip();
}

// Read an array of bytes starting from a specific address
void SRAM64::readByteArray(uint64_t beginAdr, byte* ptr, size_t dataCount) {
    for (size_t i = 0; i < dataCount; i++) {
        ptr[i] = readByte(beginAdr+i);  // Read each byte into the array
    }
}

// Read an array of 64-bit integers starting from a specific address
void SRAM64::readIntArray(uint64_t beginAdr, uint64_t* ptr, size_t dataCount) {
    selectChip();
    sendAddress(beginAdr);  // Send the 64-bit address
    for (size_t i = 0; i < dataCount; i++) {
        ptr[i] = 0;
        for (int j = 7; j >= 0; j--) {
            ptr[i] |= (uint64_t)SPI.transfer(0) << (j * 8);  // Read 64-bit integers byte by byte
        }
    }
    deselectChip();
}


SRAM64.cpp

#ifndef SRAM64_H
#define SRAM64_H

#include <SPI.h>

#define SRAM_MODE_WRITE false
#define SRAM_MODE_READ  true

class SRAM64 {
public:
    // Constructor - Takes the chip select pin number as argument
    SRAM64(int csPin, int rwPin);

    // Function to write a single byte to a specific 64-bit address
    void writeByte(uint64_t adr, byte data);

    // Function to read a single byte from a specific 64-bit address
    byte readByte(uint64_t adr);

    // Function to write a 64-bit integer to a specific 64-bit address
    void writeInt(uint64_t adr, uint64_t data);

    // Function to read a 64-bit integer from a specific 64-bit address
    uint64_t readInt(uint64_t adr);

    // Function to write an array of bytes starting at a specific address
    void writeByteArray(uint64_t beginAdr, byte* data, size_t dataCount);

    // Function to write an array of 64-bit integers starting at a specific address
    void writeIntArray(uint64_t beginAdr, uint64_t* data, size_t dataCount);

    // Function to read an array of bytes starting from a specific address
    void readByteArray(uint64_t beginAdr, byte* ptr, size_t dataCount);

    // Function to read an array of 64-bit integers starting from a specific address
    void readIntArray(uint64_t beginAdr, uint64_t* ptr, size_t dataCount);

private:
    int _csPin;  // Chip select pin
    int _rwPin;  // Read Write pin
    void selectChip();   // Function to select the chip (pull CS pin low)
    void deselectChip(); // Function to deselect the chip (pull CS pin high)
    void setMode(bool isWrite);
    void sendAddress(uint64_t adr);  // Send the 64-bit address
};

#endif


SRAM64.h

#ifndef GFXRENDERER_HPP
#define GFXRENDERER_HPP

#include <Adafruit_ILI9341.h> // Include Adafruit library for TFT
#include "gfx.hpp"

// Renderer class
class GFXRenderer {
  private:
    int rendWidth;
    int rendHeight;
    Adafruit_ILI9341 tft;

  public:
    // Constructor and deconstructor.
    GFXRenderer(int CS, int DC, int RESET);
    ~GFXRenderer();

    // Width and Height
    int width() { return rendWidth; }
    int height() { return rendHeight; }
    int width(int w) { rendWidth=w; }
    int height(int h) { rendHeight=h; }

    // Draw Shape
    void GFXDrawShape(GFXShape& shape);

    // Function to draw text
    void GFXDrawText(GFXText& textObj);

    // Get the TFT instance
    Adafruit_ILI9341& getTFT() {
      return tft;
    }
};

#endif // GFXRENDERER_HPP
