diagram.json

#include "system.h"
#include "hd44780.h" 
#include "spi.h"
//#include "ili9341.h" 
#include "st7735.h"
#include "gfx.h"
#include "fonts.h"

char * buf[10];
uint32_t stamp = 0;
uint16_t framecount = 0;
uint16_t fps = 0;

font_t * font = &LiberationSansRegular16;
const uint8_t * holiday = "ABC";

void setup() {
	spi_enable();
	//ili9341_enable(PinB2, PinB1);
	//ili9341_set_pixel(0, 0, 0xffff);

	st7735_enable(PinB0, PinB1);
	//draw_rectangle(0, 0, 127, 159, Red);
	//st7735_set_pixel(0, 0, 0xffff);

	hd44780_enable(PinC2, PinC1, PinC0, PortD);

	
}

void loop() {
	//return;
	uint32_t now = system_ms();
	if (now % 1000 < stamp % 1000) {
		fps = framecount;
		framecount = 0;
	}
	stamp = now;
	framecount++;
	sprintf(&buf, "TIME:%05lu", system_ms());
	//hd44780_print(0, 0, buf);
	draw_text(0, 0, buf, font, White, Black, false);

	sprintf(&buf, "FPS:%u", fps);
	//hd44780_print(0, 1, buf);
	draw_text(0, 30, buf, font, White, Black, false);
}


main.c

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

typedef enum {
  MODE_COMMAND,
  MODE_DATA,
} chip_mode_t;

typedef struct {
  pin_t    cs_pin;
  pin_t    dc_pin;
  pin_t    rst_pin;
  spi_dev_t spi;
  uint8_t  spi_buffer[1024];

  /* Framebuffer state */
  buffer_t framebuffer;
  uint32_t width;
  uint32_t height;

  /* Command state machine */
  chip_mode_t mode;
  uint8_t command_code;
  uint8_t command_size;
  uint8_t command_index;
  uint8_t command_buf[16];
  bool ram_write;

  // Memory and addressing settings
  uint32_t active_column;
  uint32_t active_page;
  uint32_t column_start;
  uint32_t column_end;
  uint32_t page_start;
  uint32_t page_end;
  uint32_t scanning_direction;
} chip_state_t;

/* Chip command codes */
#define CMD_NOP      (0x00) // No Operation
#define CMD_SWRESET  (0x01)
#define CMD_SLPIN    (0x10) // Sleep In
#define CMD_SLPOUT   (0x11) // Sleep Out
#define CMD_INVOFF   (0x20) // Display Inversion Off
#define CMD_INVON    (0x21) // Display Inversion On
#define CMD_DISPOFF  (0x28) // Display Inversion On
#define CMD_DISPON   (0x29) // Display Inversion On
#define CMD_CASET    (0x2a) // Column Address Set
#define CMD_PASET    (0x2b) // Page Address Set
#define CMD_RAMWR    (0x2c) // Memory Write
#define CMD_MADCTL   (0x36) // Memory Access Control
#define CMD_COLMOD   (0x3a) // Set 16-bit pixel format
#define CMD_FRMCTR1  (0xb1) // Frame rate control 1, use by default
#define CMD_FRMCTR2  (0xb2) // Frame Rate Control (In Idle mode / 8-colors)
#define CMD_FRMCTR3  (0xb3) // Frame Rate Control (In Partial mode / full colors)
#define CMD_INVCTR   (0xb4) // Display inversion, use by default
#define CMD_DISSET5  (0xb6)
#define CMD_PWCTR1   (0xc0) // Power control 1
#define CMD_PWCTR2   (0xc1)
#define CMD_PWCTR3   (0xc2) // Power control 3
#define CMD_PWCTR4   (0xc3) // Power Control 4 (in Idle mode/ 8-colors)
#define CMD_PWCTR5   (0xc4) // Power Control 5 (in Partial mode/ full-colors)
#define CMD_VMCTR    (0xc5) // VCom control 1
#define CMD_GMCTRP1  (0xe0) // positive gamma correction
#define CMD_GMCTRN1  (0xe1) // negative gamma correction

/* Scanning direction bits */
#define SCAN_MY (0b10000000)
#define SCAN_MX (0b01000000)
#define SCAN_MV (0b00100000)

static void chip_pin_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_reset(chip_state_t *chip) {
  chip->ram_write = false;
  chip->active_column = 0;
  chip->active_page = 0;
  chip->column_start = 0;
  chip->column_end = 127;
  chip->page_start = 0;
  chip->page_end = 7;
}

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

  const pin_watch_config_t watch_config = {
    .edge = BOTH,
    .pin_change = chip_pin_change,
    .user_data = chip,
  };
  
  chip->cs_pin = pin_init("CS", INPUT_PULLUP);
  pin_watch(chip->cs_pin, &watch_config);

  chip->dc_pin = pin_init("DC", INPUT);
  pin_watch(chip->dc_pin, &watch_config);

  chip->rst_pin = pin_init("RST", INPUT_PULLUP);
  pin_watch(chip->rst_pin, &watch_config);

  const spi_config_t spi_config = {
    .sck = pin_init("SCL", INPUT),
    .mosi = pin_init("SDA", INPUT),
    .miso = NO_PIN,
    .done = chip_spi_done,
    .user_data = chip,
  };
  chip->spi = spi_init(&spi_config);

  chip->framebuffer = framebuffer_init(&chip->width, &chip->height);

  chip_reset(chip);
}

/* Converts a 16-bit RGB565 (5 bits for red, 6 for green, 5 for blue) into 32-bit RGBA (8-bit per channel) */
uint32_t rgb565_to_rgba(uint16_t value) {
  return 0xff000000  // Alpha
         | ((value & 0x001f) << 19) // Blue
         | ((value & 0x07e0) << 5) // Green
         | ((value & 0xf800) >> 8); // Red
}

void chip_pin_change(void *user_data, pin_t pin, uint32_t value) {
  chip_state_t *chip = (chip_state_t*)user_data;

  // Handle CS pin logic
  if (pin == chip->cs_pin) {
    if (value == LOW) {
      chip->command_size = 0;
      chip->command_index = 0;
      spi_start(chip->spi, chip->spi_buffer, sizeof(chip->spi_buffer));
    } else {
      spi_stop(chip->spi);
    }
  }

  // Handle DC pin logic
  if (pin == chip->dc_pin && chip->mode != value) {
    spi_stop(chip->spi); // Process remaining data in SPI buffer
    chip->mode = value;
    if (pin_read(chip->cs_pin) == LOW) {
      spi_start(chip->spi, chip->spi_buffer, sizeof(chip->spi_buffer));
    }
  }

  if (pin == chip->rst_pin && value == LOW) {
    spi_stop(chip->spi); // Process remaining data in SPI buffer
    chip_reset(chip);
  }
}

int command_args_size(uint8_t command_code) {
  switch (command_code) {
    case CMD_MADCTL:
    case CMD_PWCTR2:
    case CMD_INVCTR:
    case CMD_VMCTR:
    case CMD_COLMOD:  return 1;
    case CMD_PWCTR3:
    case CMD_PWCTR4:
    case CMD_PWCTR5:
    case CMD_DISSET5: return 2;
    case CMD_FRMCTR1:
    case CMD_FRMCTR2:
    case CMD_PWCTR1:  return 3;
    case CMD_CASET:
    case CMD_PASET:   return 4;
    case CMD_FRMCTR3: return 6;
    case CMD_GMCTRP1:
    case CMD_GMCTRN1: return 16;
    default:          return 0;
  }
}

void execute_command(chip_state_t *chip) {
  //printf("exec command %02X\n", chip->command_code);
  switch (chip->command_code) {
    case CMD_NOP: 
      break;

    case CMD_SLPIN:
    case CMD_DISPOFF:
      // Not implemented.
      break;

    case CMD_SLPOUT:
    case CMD_DISPON:
      // Not implemented.
      break;

    case CMD_INVOFF:
    case CMD_INVON:
      // Not implemented.
      break;

    case CMD_RAMWR:
      chip->ram_write = true;
      break;

    case CMD_MADCTL:
      chip->scanning_direction = chip->command_buf[0] & 0xfc;
      break;

    case CMD_CASET:
    case CMD_PASET: {
      //printf("XASET\n");
      uint16_t arg0 = (chip->command_buf[0] << 8) | chip->command_buf[1];
      uint16_t arg2 = (chip->command_buf[2] << 8) | chip->command_buf[3];
      bool set_page = chip->command_code == CMD_PASET;
      if ((chip->scanning_direction & SCAN_MV) ? !set_page : set_page) {
        chip->active_page = arg0;
        chip->page_start = arg0;
        chip->page_end = arg2;
        if (chip->scanning_direction & SCAN_MY) {
          chip->active_page -= 32;
          chip->page_start -= 32;
          chip->page_end -= 32;
        }
      } else {
        chip->active_column = arg0;
        chip->column_start = arg0;
        chip->column_end = arg2;
      }
      break;
    }

    case CMD_PWCTR1:
    case CMD_SWRESET:
    case CMD_COLMOD:
    case CMD_VMCTR:
    case 0x13:
    case 0xe1:
    case 0xe0:
    case 0xc4:
    case 0xc3:
    case 0xc2:
    case 0xc1:
    case 0xb4:
    case 0xb3:
    case 0xb2:
    case 0xb1:
    case 0xb6:
      // Not implemented.
      break;

    default:
      printf("Warning: unknown command 0x%02x\n", chip->command_code);
      break;
  }
}

void process_command(chip_state_t *chip, uint8_t *buffer, uint32_t buffer_size) {
  chip->ram_write = false;
  for (int i = 0; i < buffer_size; i++) {
    chip->command_code = buffer[i];
    chip->command_size = command_args_size(chip->command_code);
    chip->command_index = 0;
    if (!chip->command_size) {
      execute_command(chip);
    }
  }
}

void process_command_args(chip_state_t *chip, uint8_t *buffer, uint32_t buffer_size) {
  for (int i = 0; i < buffer_size; i++) {
    if (chip->command_index < chip->command_size) {
      chip->command_buf[chip->command_index++] = buffer[i];
      if (chip->command_size == chip->command_index) {
        execute_command(chip);
      }
    }
  }
}

void process_data(chip_state_t *chip, const uint16_t *buffer16, uint32_t buffer_size) {
  //printf("RAMWRITE size:%u\n", buffer_size);
  uint32_t color;

  for (int i = 0; i < buffer_size; i++) {
    int x = chip->active_column;
    int y = chip->active_page;
    if (chip->scanning_direction & SCAN_MV) {
      x = chip->scanning_direction & SCAN_MX ? (chip->width - 1 - x) : x;
      y = chip->scanning_direction & SCAN_MY ? (chip->height - 1 - y) : y;
    } else {
      x = chip->scanning_direction & SCAN_MY ? (chip->width - 1 - x) : x;
      y = chip->scanning_direction & SCAN_MX ? (chip->height - 1 - y) : y;
    }

    color = rgb565_to_rgba(buffer16[i]);
    //int pix_index = y * chip->width + x;
    int pix_index = y * chip->width + x;
    buffer_write(chip->framebuffer, pix_index * sizeof(color), &color, sizeof(color));

    if (chip->scanning_direction & SCAN_MV) {
      chip->active_page++;
      if (chip->active_page > chip->page_end) {
        chip->active_page = chip->page_start;
        chip->active_column++;
        if (chip->active_column > chip->column_end) {
          chip->active_column = chip->column_start;
        }
      }
    } else {
      chip->active_column++;
      if (chip->active_column > chip->column_end) {
        chip->active_column = chip->column_start;
        chip->active_page++;
        if (chip->active_page > chip->page_end) {
          chip->active_page = chip->page_start;
        }
      }
    }
  }
}

void chip_spi_done(void *user_data, uint8_t *buffer, uint32_t count) {
  chip_state_t *chip = (chip_state_t*)user_data;
  if (!count) {
    // This means that we got here from spi_stop, and no data was received
    return;
  }

  if (chip->mode == MODE_DATA) {
    if (chip->ram_write) {
      process_data(chip, (const uint16_t*)buffer, count / 2);
    } else {
      process_command_args(chip, buffer, count);
    }
  } else {
    process_command(chip, buffer, count);
  }


  if (pin_read(chip->cs_pin) == LOW) {
    // Receive the next buffer
    spi_start(chip->spi, chip->spi_buffer, sizeof(chip->spi_buffer));
  }
}


st7735.chip.c

ST7735S [128x160]

st7735.chip.json

fonts.h

#include <avr/pgmspace.h>
#include "gfx.h"
#include "string.h"
//#include "ili9341.h"
#include "st7735.h"

#define write_block st7735_write_block
#define set_block st7735_set_block
#define set_pixel st7735_set_pixel

long map(long x, long in_min, long in_max, long out_min, long out_max) {
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

void draw_text(uint16_t x, uint16_t y, const uint8_t * text, font_t * font, rgb888_t color, rgb888_t bgcolor, bool rtl) {
	if (strlen((const char *)text) > 40)
		return;
	uint8_t bh = ((font->height * (font->smooth * 2) - 1) / 8 + 1);
	int16_t offset = 0;

	for (int chx = 0; chx < strlen((const char *)text); chx++) {
		uint8_t chr = text[chx] - font->offset;
		uint16_t char_offset = 0;
		for (int i = 0; i < chr; i++)
			char_offset += font->widths[i] * bh;
		for (int cl = 0; cl < font->widths[chr]; cl++) {
			uint8_t rcl = (rtl ? font->widths[chr] - cl - 1 : cl);

			uint8_t pixels[2 * bh * 4];
			for (int b = 0; b < bh; b++) {
				uint8_t val = pgm_read_byte_near(font->data + (char_offset + bh * rcl + b));
				//uint8_t val = font->data[char_offset + bh * rcl + b];
				if (font->smooth) {
					for (int p = 0; p < 4; p++) {
						uint8_t v = (val >> (2 * p)) & 0b11;
						int ratio = ((uint8_t[]){0, 50, 70, 100})[v];
						rgb888_t rgb;
						rgb.red = map(ratio, 0, 100, bgcolor.red, color.red);
						rgb.green = map(ratio, 0, 100, bgcolor.green, color.green);
						rgb.blue = map(ratio, 0, 100, bgcolor.blue, color.blue);
						uint16_t col = RGB565(rgb);
						pixels[2 * (bh * b + p)] = col >> 8;
						pixels[2 * (bh * b + p) + 1] = col & 0xff;
						//set_pixel(100 + x + offset, y + 4 * b + p, col);
					}
				} else {
					for (int p = 0; p < 8; p++) {
						uint8_t v = (val >> p) & 1;
						uint16_t col;
						if (v)
							col = RGB565(color);
						else
							col = RGB565(bgcolor);
						//set_pixel(x + offset, y + 8 * b + p, col);
					}
				}
			}
			write_block(x + offset, y, 1, 4 * 4, &pixels[0]);
			if (rtl)
				offset--;
			else
				offset++;
		}
	}
}

uint16_t text_width(uint8_t * text, font_t * font) {
	uint16_t width = 0;
	for (int c = 0; c < strlen((const char *)text); c++)
		width += font->widths[text[c] - font->offset];
	return width;
}

void draw_rectangle(uint16_t x, uint16_t y, uint16_t w, uint16_t h, rgb888_t color) {
	set_block(x, y, w, h, RGB565(color));
}

void draw_text_box(uint16_t x, uint16_t y, uint16_t width, uint16_t h, uint8_t * text, font_t * font, rgb888_t color, rgb888_t bgcolor, align_t align, bool rtl) {
	//draw_rectangle((rtl ? x: width - 1 - x), y, width, h, bgcolor);	
	uint16_t pad = 0;
	uint16_t tw = text_width(text, font);
	if (align == AlignRight)
		pad = width - tw;
	else if (align == AlignCenter)
		pad = (width - tw) / 2;
	if (rtl)
		draw_text(x + pad + tw, y, text, font, color, bgcolor, rtl);
	else
		draw_text(x + pad, y, text, font, color, bgcolor, rtl);
}



gfx.c

#ifndef _gfx_h_
#define _gfx_h_
#include "spi.h"
#include <stdint.h>
#include <stdbool.h>
#include <avr/pgmspace.h>

typedef struct __attribute__ ((__packed__)) {
	bool smooth;
	uint8_t height;
	uint8_t offset;
	uint8_t num_chars;
	const uint8_t * widths;
	const uint8_t * data;
} font_t;

typedef enum {
	AlignRight,
	AlignLeft,
	AlignCenter
} align_t;

typedef union {
	uint32_t value;
	uint8_t values[4];
	struct {
		uint8_t alpha;
		uint8_t red;
		uint8_t green;
		uint8_t blue;
	};
} rgb888_t;

#define Red         (rgb888_t){0x00FF0000}
#define Orange      (rgb888_t){0x00FF7D00}
#define Yellow      (rgb888_t){0x00FFFF00}
#define Green       (rgb888_t){0x0000FF00}
#define SpringGreen (rgb888_t){0x007DFF00}
#define Turquoise   (rgb888_t){0x00FF7D00}
#define Cyan        (rgb888_t){0x00FFFF00}
#define Ocean       (rgb888_t){0x007DFF00}
#define Blue        (rgb888_t){0x000000FF}
#define Violet      (rgb888_t){0x007D00FF}
#define Magenta     (rgb888_t){0x00FF00FF}
#define Raspberry   (rgb888_t){0x00FF007D}

#define White       (rgb888_t){0x00FFFFFF}
#define LightGray   (rgb888_t){0x00D3D3D3}
#define Silver      (rgb888_t){0x00C0C0C0}
#define Gray        (rgb888_t){0x00808080}
#define DarkGray    (rgb888_t){0x00A9A9A9}
#define Black       (rgb888_t){0x00000000}

#define RGB565(c) (((c.red >> 3) << 11) | ((c.green >> 2) << 5) | c.blue >> 3)

#ifdef __cplusplus
extern "C" {
#endif
uint16_t text_width(uint8_t * text, font_t * font);
void draw_text(uint16_t x, uint16_t y, const uint8_t * text, font_t * font, rgb888_t color, rgb888_t bgcolor, bool rtl);
void draw_text_box(uint16_t x, uint16_t y, uint16_t width, uint16_t h, uint8_t * text, font_t * font, rgb888_t color, rgb888_t bgcolor, align_t align, bool rtl);
void draw_rectangle(uint16_t x_, uint16_t y_, uint16_t w, uint16_t h, rgb888_t color);
#ifdef __cplusplus
}
#endif
#endif


gfx.h

#include <avr/io.h>
#include <stdbool.h>
#include "gpio.h"

void pin_mode(pin_t pin, pin_mode_t mode) {
	gpio_t * gpio = GPIO(pin_port(pin));
	switch (mode) {
		case Input:
			gpio->DDR &= pin_mask(pin);
			gpio->PORT &= pin_mask(pin);
			break;
		case InputPullup:
			gpio->DDR &= ~pin_mask(pin);
			gpio->PORT |= pin_mask(pin);
			break;
		case Output:
			gpio->DDR |= pin_mask(pin);
			gpio->PORT &= ~pin_mask(pin);
			break;
	}
}

void port_mode(port_t port, pin_mode_t mode) {
	gpio_t * gpio = GPIO(port);
	switch (mode) {
		case Input:
			gpio->DDR = 0x00;
			gpio->PORT = 0x00;
			break;
		case InputPullup:
			gpio->DDR = 0x00;
			gpio->PORT = 0xFF;
			break;
		case Output:
			gpio->DDR = 0xFF;
			gpio->PORT = 0x00;
			break;
	}
}

void pin_set(pin_t pin) {
	GPIO(pin_port(pin))->PORT |= pin_mask(pin);
}

void pin_reset(pin_t pin) {
	GPIO(pin_port(pin))->PORT &= ~pin_mask(pin);
}

void pin_write(pin_t pin, bool value) {
	if (value)
		pin_set(pin);
	else
		pin_reset(pin);
}

bool pin_read(pin_t pin) {
	return GPIO(pin_port(pin))->PIN & pin_mask(pin);
}
void port_write_byte(port_t port, uint8_t value) {
	GPIO(port)->PORT = value;
}

uint8_t port_read_byte(port_t port) {
	return GPIO(port)->PIN;
}


gpio.c

#ifndef _gpio_h
#define _gpio_h
#include <stdint.h>
#include <stdbool.h>

typedef volatile struct {
	uint8_t PIN;
	uint8_t DDR;
	uint8_t PORT;
} gpio_t;

#define GPIO(x) ((gpio_t *)(0x20 + 3	* x))

typedef enum {
	Input,
	InputPullup,
	Output,
} pin_mode_t;

typedef enum {
	PortA = 0,
	PortB = 1,
	PortC = 2,
	PortD = 3,
} port_t;

typedef enum {
	PinA0 = 0x00,
	PinA1 = 0x01,
	PinA2 = 0x02,
	PinA3 = 0x03,
	PinA4 = 0x04,
	PinA5 = 0x05,
	PinA6 = 0x06,
	PinA7 = 0x07,
	PinB0 = 0x10,
	PinB1 = 0x11,
	PinB2 = 0x12,
	PinB3 = 0x13,
	PinB4 = 0x14,
	PinB5 = 0x15,
	PinB6 = 0x16,
	PinB7 = 0x17,
	PinC0 = 0x20,
	PinC1 = 0x21,
	PinC2 = 0x22,
	PinC3 = 0x23,
	PinC4 = 0x24,
	PinC5 = 0x25,
	PinC6 = 0x26,
	PinC7 = 0x27,
	PinD0 = 0x30,
	PinD1 = 0x31,
	PinD2 = 0x32,
	PinD3 = 0x33,
	PinD4 = 0x34,
	PinD5 = 0x35,
	PinD6 = 0x36,
	PinD7 = 0x37,
} pin_t;

//#define pin_port(pin) ((port_t) (pin >> 4))
//#define pin_number(pin) (pin & 0x0F)
//#define pin_mask(pin) ((uint8_t)(1 << pin_number(pin)))

#ifdef __cplusplus
extern "C" {
#endif

inline port_t pin_port(pin_t pin) {
	return pin >> 4;
}

inline uint8_t pin_number(pin_t pin) {
	return pin & 0x0F;
}

inline uint8_t pin_mask(pin_t pin) {
	return 1 << pin_number(pin);
}

void pin_mode(pin_t pin, pin_mode_t mode);
void pin_set(pin_t pin);
void pin_reset(pin_t pin);
void pin_write(pin_t pin, bool value);
bool pin_read(pin_t pin);
void port_mode(port_t port, pin_mode_t mode);
void port_write_byte(port_t port, uint8_t value);
uint8_t port_read_byte(port_t port);

#ifdef __cplusplus
}
#endif
#endif


gpio.h

#include <avr/io.h>
#include "spi.h"
#include "gpio.h"

#define SCK PinB5
#define MISO PinB4
#define MOSI PinB3

void spi_enable() {
	pin_mode(SCK, Output);
	pin_mode(MOSI, Output);
	SPCR = _BV(SPE) | _BV(MSTR) | _BV(SPR0); // clock/4
}

void spi_disable() {
	SPCR = 0;
	pin_mode(SCK, Input);
	pin_mode(MOSI, Input);
}

uint8_t spi_transfer8(uint8_t data) {
	SPDR = data;
	while (!(SPSR & _BV(SPIF)));
	return SPDR;
}

void spi_transfer(uint8_t * data, uint8_t len) {
	uint8_t *p = data;
	SPDR = *p;
	while (--len > 0) {
		uint8_t out = *(p + 1);
		while (!(SPSR & _BV(SPIF)));
		uint8_t in = SPDR;
		SPDR = out;
		*p++ = in;
	}
}


spi.c

#ifndef _spi_h_
#define _spi_h_

#ifdef __cplusplus
extern "C" {
#endif

void spi_enable();
void spi_disable();
uint8_t spi_transfer8(uint8_t data);
void spi_transfer(uint8_t * data, uint8_t len);

#ifdef __cplusplus
}
#endif
#endif


spi.h

#include "st7735.h"
#include "system.h"
#include "gpio.h"
#include "spi.h"
#include <stdint.h>
#include <stdbool.h>

static pin_t _cspin;
static pin_t _dcpin;

typedef enum {
	// system commands
	NOP       = 0x00,
	SWRESET   = 0x01, // Sowtware Reset
	RDDID     = 0x04, // Read Display ID
	RDDST     = 0x09, // Read Display Status
	RDDPM     = 0x0A, // Read Display Power Mode
	RDDMADCTL = 0x0B, // Read Display MADCTL
	RDDCOLMOD = 0x0C, // Read Display Pixel Format
	RDDIM     = 0x0D, // Read Display Image Mode
	RDDSM     = 0x0E, // Read Display Signal Mode
	RDDSDR    = 0x0F, // Read Display Self-Diagnostic Result
	SLPIN     = 0x10, // Sleep In
	SLPOUT    = 0x11, // Sleep Out
	PTLON     = 0x12, // Partial Display Mode On
	NORON     = 0x13, // Normal Display Mode On
	INVOFF    = 0x20, // Display Inversion Off
	INVON     = 0x21, // Display Inversion On
	GAMSET    = 0x26, // Gamma Set
	DISPOFF   = 0x28, // Display Inversion On
	DISPON    = 0x29, // Display Inversion On
	CASET     = 0x2A, // Column Address Set
	RASET     = 0x2B, // Row Address Set
	RAMWR     = 0x2C, // Memory Write
	RGBSET		= 0x2D, // Color setting for 4K, 65K and 262K
	RAMRD     = 0x2E, // Memory Read
	PTLAR			= 0x30, // Partial Area
	SCRLAR		= 0x31, // Scroll Area Set
	TEFF      = 0x34, // Tearing Effect Line Off
	TEON      = 0x35, // Tearing Efect Line Off
	MADCTL    = 0x36, // Memory Access Control
	VSCSAD    = 0x37, // Vertical Scroll Start Address
	IDLOFF    = 0x38, // Idle Mode Off
	IDLON			= 0x39, // Idle Mode On
	COLMOD    = 0x3A, // Interface Pixel Format
	RDID1     = 0xDA,
	RDID2     = 0xDB,
	RDID3     = 0xDC,
	// panel commands
	FRMCTR1   = 0xb1, // Frame rate control 1, use by default
	FRMCTR2   = 0xb2, // Frame Rate Control (In Idle mode / 8-colors)
	FRMCTR3   = 0xb3, // Frame Rate Control (In Partial mode / full colors)
	INVCTR    = 0xb4, // Display inversion, use by default
	PWCTR1    = 0xC0, // Power control 1
	PWCTR2    = 0xC1,
	PWCTR3    = 0xC2, // Power control 3
	PWCTR4    = 0xC3, // Power Control 4 (in Idle mode/ 8-colors,
	PWCTR5    = 0xC4, // Power Control 5 (in Partial mode/ full-colors,
	VMCTR1    = 0xC5, // VCom control 1
	VMOFCTR   = 0xC7,
	WRID2     = 0xD1,
	WRID3     = 0xD2,
	NVFCTR1   = 0xD9,
	NVFCTR2   = 0xDE,
	NVFCTR3   = 0xDF,
	GMCTRP1   = 0xE0, // positive gamma correction
	GMCTRN1   = 0xE1, // negative gamma correction
	GCV				= 0xFC, // Gate Pump Clock Frequency Variable
} st7735_command_t;

#define MADCTL_MX  0x80 // row address order 0=top to bottom, 1=bottom to top
#define MADCTL_MY  0x40 // column addres order 0=left to right, 1=right to left
#define MADCTL_MV  0x20 // row/column exchange
#define MADCTL_ML  0x10 // vertical refresh order
#define MADCTL_BGR 0x08 // rgb/grb order
#define MADCTL_MH  0x04 // horizontal refresh order

static void chip_select() {
	pin_reset(_cspin);
}

static void chip_deselect() {
	pin_set(_cspin);
}

static void command(uint8_t cmd) {
	pin_reset(_dcpin);
	spi_transfer8(cmd);
}

static void write_data(uint8_t data) {
	pin_set(_dcpin);
	spi_transfer8(data);
}

static void command1(uint8_t cmd, uint8_t p1) {
	pin_reset(_dcpin);
	spi_transfer8(cmd);
	pin_set(_dcpin);
	spi_transfer8(p1);
}

static void command2(uint8_t cmd, uint8_t p1, uint8_t p2) {
	pin_reset(_dcpin);
	spi_transfer8(cmd);
	pin_set(_dcpin);
	spi_transfer8(p1);
	spi_transfer8(p2);
}

static void command3(uint8_t cmd, uint8_t p1, uint8_t p2, uint8_t p3) {
	pin_reset(_dcpin);
	spi_transfer8(cmd);
	pin_set(_dcpin);
	spi_transfer8(p1);
	spi_transfer8(p2);
	spi_transfer8(p3);
}

static void command4(uint8_t cmd, uint8_t p1, uint8_t p2, uint8_t p3, uint8_t p4) {
	pin_reset(_dcpin);
	spi_transfer8(cmd);
	pin_set(_dcpin);
	spi_transfer8(p1);
	spi_transfer8(p2);
	spi_transfer8(p3);
	spi_transfer8(p4);
}

static void command6(uint8_t cmd, uint8_t p1, uint8_t p2, uint8_t p3, uint8_t p4, uint8_t p5, uint8_t p6) {
	pin_reset(_dcpin);
	spi_transfer8(cmd);
	pin_set(_dcpin);
	spi_transfer8(p1);
	spi_transfer8(p2);
	spi_transfer8(p3);
	spi_transfer8(p4);
	spi_transfer8(p5);
	spi_transfer8(p6);
}

void st7735_set_rotation(int rotation) {
	chip_select();
	switch (rotation) {
		case 0:
				command1(MADCTL, 0);
				break;
		case 1:
				command1(MADCTL, MADCTL_MX | MADCTL_MV);
				break;
		case 2:
				command1(MADCTL, MADCTL_MY);
				break;
		case 3:
				command1(MADCTL, MADCTL_MY | MADCTL_MV);
				break;
	}
	chip_deselect();
}

void st7735_enable(pin_t cspin, pin_t dcpin) {
	_cspin = cspin;
	_dcpin = dcpin;
  pin_mode(_cspin, Output);
	pin_set(_cspin);
  pin_mode(_dcpin, Output);
	chip_select();
	command(SWRESET);
	delay_ms(50);
	command(SLPOUT);
	delay_ms(500);
	command3(FRMCTR1,
      1,
      0x2C,
      0x2D);
	//_delay_ms(10);
	command3(FRMCTR2,
      1,
      0x2C,
      0x2D);
	command6(FRMCTR3,
    1, 0x2C, 0x2D,
    1, 0x2C, 0x2D);
  command1(INVCTR, 7);
	command3(PWCTR1,
		0xA2, // avdd=5v, gvdd=4.6v
		0x02, // gvcl=-4.6v
		0x84); // mode=auto, vrhp5,vrhn5=0
	//_delay_ms(10);
	command1(PWCTR2,
			0xC5); // vgh25=2.4v vghbt=1(vgh=3*avdd-0.5) vgh=14.5v vgl=-10v
	command2(PWCTR3, // opamp curent in normal/full mode
		0x0A, // ap=small sap=medium-low
		0x00); // boost frequency
	command2(PWCTR4, // opamp current in idle/8-colors mode
		0x8A, // ap=small sap=medium-low
		0x2A); // boost frequency
	command2(PWCTR5, // opamp current in partial/full-color mode
		0x8A, // ap=small sap=medium-low
		0xEE);//0x2A); // boost frequency
	command1(VMCTR1, 0x0E); // -0.775
	command(INVOFF);
	command1(COLMOD, 0x05); // 16bit/px
	// gamma 0xE0 02 1c 07 12 37 32 29 2d 29 25 2b 39 00 01 03 10
	// gamma 0xE1 03 1d 07 06 2e 2c 29 2d 2e 2e 37 3f 00 00 03 01
	command(NORON);
	command(DISPON);
	delay_ms(100);
	st7735_set_rotation(0);
	chip_deselect();
}

void st7735_disable() {
	chip_select();
	command(DISPOFF);
	command(SLPIN);
	chip_deselect();
}

void st7735_set_pixel(uint16_t x, uint16_t y, uint16_t color) {
	chip_select();
	uint8_t xh = x >> 8, xl = x & 0xff;
	uint8_t yh = y >> 8, yl = y & 0xff;
	uint8_t ch = (uint16_t)color >> 8, cl = (uint16_t)(color & 0xff);
	command4(CASET, xh, xl, xh, xl);
	command4(RASET, yh, yl, yh, yl);
	command(RAMWR);
	write_data(ch);
	write_data(cl);
	chip_deselect();
}

void st7735_write_block(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint8_t * data) {
	uint16_t x2 = x + w - 1;
	uint16_t y2 = y + h - 1;
	chip_select();
	command4(CASET, x >> 8, x & 0xFF, x2 >> 8, x2 & 0xFF);
	command4(RASET, y >> 8, y & 0xFF, y2 >> 8, y2 & 0xFF);
	command(RAMWR);
	for (int i = 0; i < w * h * 2; i++)
		write_data(data[i]);
	chip_deselect();
}

void st7735_set_block(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t color) {
	uint16_t x2 = x + w - 1;
	uint16_t y2 = y + h - 1;
	chip_select();
	command4(CASET, x >> 8, x & 0xFF, x2 >> 8, x2 & 0xFF);
	command4(RASET, y >> 8, y & 0xFF, y2 >> 8, y2 & 0xFF);
	command(RAMWR);
	for (int i = 0; i < w * h; i++) {
		write_data(color >> 8);
		write_data(color & 0xFF);
	}
	chip_deselect();
}


st7735.c

#ifndef _st7735_h
#define _st7735_h
#include "gpio.h"
#include <stdint.h>
#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif

void st7735_enable(pin_t cspin, pin_t dcpin);
void st7735_disable();
void st7735_set_rotation(int rotation);
void st7735_set_pixel(uint16_t x, uint16_t y, uint16_t color);
void st7735_set_block(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t color);
void st7735_write_block(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint8_t * data);

#ifdef __cplusplus
}
#endif
#endif


st7735.h

#include <avr/io.h>
#include <avr/interrupt.h>
#include "system.h"
#include <stdint.h>

static volatile uint64_t _microseconds;

ISR(TIMER0_OVF_vect) {
	_microseconds += 1024;
}

uint64_t system_us() {
	volatile uint8_t sreg = SREG;
	cli();
	uint64_t v = _microseconds;
	SREG = sreg;
	return v;
}

uint32_t system_ms() {
	return system_us() / 1000;
}

void delay_ms(uint32_t ms) {
	uint32_t until = system_ms() + ms;
	while (system_ms() < until);
}

void system_init(void) {
	sei();
	TCCR0A |= _BV(WGM00) | _BV(WGM01);
	TCCR0B |= _BV(CS00) | _BV(CS01); //clk/64
	TIMSK0 |= _BV(TOIE0);
}

int main() {
	system_init();
	setup();
	while (1)
		loop();
}


system.c

#ifndef _system_h
#define _system_h
#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

uint64_t system_us();
uint32_t system_ms();
void delay_ms(uint32_t ms);
void setup();
void loop();

#ifdef __cplusplus
}
#endif
#endif


system.h

#include "hd44780.h"
#include "gpio.h"

typedef enum {
	CLEAR_DISPLAY = 0x01,
	RETURN_HOME = 0x02,
	ENTRY_MODE_SET = 0x04,
	DISPLAY_ON_OFF_CONTROL = 0x08,
	CURSOR_OR_DISPLAY_SHIFT = 0x10,
	FUNCTION_SET = 0x20,
	SET_CGRAM_ADDRESS = 0x40,
	SET_DDRAM_ADDRESS = 0x80,
} hd44780_command_t;

static pin_t _rs_pin;
static pin_t _rw_pin;
static pin_t _e_pin;
static port_t _data_port;

static void hd44780_write(uint8_t data, bool rs) {
	// TODO: delay
	pin_reset(_e_pin);
	pin_write(_rs_pin, rs);
	pin_reset(_rw_pin);
	port_mode(_data_port, Output);
	port_write_byte(_data_port, data);
	pin_set(_e_pin);
	pin_reset(_e_pin);
	pin_set(_rw_pin);
	port_mode(_data_port, Input);
	while (port_read_byte(_data_port) & 0x80);
}

static void hd44780_write_command(uint8_t command) {
	hd44780_write(command, false);
}

static void hd44780_write_data(uint8_t data) {
	hd44780_write(data, true);
}

void hd44780_enable(pin_t rs_pin, pin_t rw_pin, pin_t e_pin, port_t data_port) {
	_rs_pin = rs_pin;
	_rw_pin = rw_pin;
	_e_pin = e_pin;
	_data_port = data_port;
	pin_mode(_rs_pin, Output);
	pin_mode(_rw_pin, Output);
	pin_mode(_e_pin, Output);
	port_mode(_data_port, Output);
	hd44780_write_command(DISPLAY_ON_OFF_CONTROL + 4);
	hd44780_write_command(CLEAR_DISPLAY);
}

void hd44780_disable() {
	hd44780_write_command(DISPLAY_ON_OFF_CONTROL);
}

void hd44780_print(uint8_t x, uint8_t y, uint8_t * data) {
	uint8_t addr = (uint8_t[]){0, 64, 20, 84}[y] + x;
	hd44780_write_command(SET_DDRAM_ADDRESS + addr);
	uint8_t i = 0;
	while (data[i] != 0)
		hd44780_write_data(data[i++]);
}


hd44780.c

#ifndef _hd44780_h
#define _hd44780_h
#include "gpio.h"
#include <stdint.h>
#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif

void hd44780_enable(pin_t rs_pin, pin_t rw_pin, pin_t e_pin, port_t data_port);
void hd44780_disable();
void hd44780_print(uint8_t x, uint8_t y, uint8_t * data);

#ifdef __cplusplus
}
#endif
#endif
