diagram.json

#include "system.h"
#include "hd44780.h"
#include "spi.h"
#include "ili9341.h"

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

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

	hd44780_enable(PinC2, PinC1, PinC0, PortD);
}

void loop() {
	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);
	sprintf(&buf, "FPS: %u", fps);
	hd44780_print(0, 1, buf);
	ili9341_set_block(10, 10, 20, 40, system_ms());

	delay_ms(1000);
}


main.c

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

void pin_mode(pin_t pin, pin_mode_t mode) {
	volatile uint8_t * portx = 0x20 + (2 + 3 * (pin >> 8));
	volatile uint8_t * ddrx = 0x20 + (1 + 3 * (pin >> 8));
  uint8_t pin_mask = pin & 0xff;
	switch (mode) {
		case Input:
      *ddrx &= ~pin_mask;
			*portx &= ~pin_mask;
			break;
		case InputPullup:
      *ddrx &= ~pin_mask;
      *portx |= pin_mask;
			break;
		case Output:
			*ddrx |= pin_mask;
      *portx &= ~pin_mask;
			break;
	}
}

void port_mode(port_t port, pin_mode_t mode) {
	volatile uint8_t * portx = 0x20 + (2 + 3 * (port));
	volatile uint8_t * ddrx = 0x20 + (1 + 3 * port);
	switch (mode) {
		case Input:
			*ddrx = 0;
			*portx = 0;
			break;
		case InputPullup:
      *ddrx = 0;
      *portx = 0xff;
			break;
		case Output:
			*ddrx = 0xff;
			*portx = 0;
			break;
	}
}

void pin_set(pin_t pin) {
	volatile uint8_t * portx = 0x20 + (2 + 3 * (pin >> 8));
  uint8_t pin_mask = pin & 0xff;
  *portx |= pin_mask;
}

void pin_reset(pin_t pin) {
	volatile uint8_t * portx = 0x20 + (2 + 3 * (pin >> 8));
  uint8_t pin_mask = pin & 0xff;
  *portx &= ~pin_mask;
}

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

bool pin_read(pin_t pin) {
	volatile uint8_t * portx = 0x20 + (2 + 3 * (pin >> 8));
	return *portx & (pin & 0xff);
}
void port_write_byte(port_t port, uint8_t value) {
	volatile uint8_t * portx = 0x20 + (2 + 3 * (port));
	*portx = value;
}

uint8_t port_read_byte(port_t port) {
	volatile uint8_t * portx = 0x20 + (2 + 3 * (port));
	return *portx;
}


gpio.c

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

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

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

typedef enum {
  PinA0 = 0x0001,
  PinA1 = 0x0002,
  PinA2 = 0x0004,
  PinA3 = 0x0008,
  PinA4 = 0x0010,
  PinA5 = 0x0020,
  PinA6 = 0x0040,
  PinA7 = 0x0080,
  PinB0 = 0x0101,
  PinB1 = 0x0102,
  PinB2 = 0x0104,
  PinB3 = 0x0108,
  PinB4 = 0x0110,
  PinB5 = 0x0120,
  PinB6 = 0x0140,
  PinB7 = 0x0180,
  PinC0 = 0x0201,
  PinC1 = 0x0202,
  PinC2 = 0x0204,
  PinC3 = 0x0208,
  PinC4 = 0x0210,
  PinC5 = 0x0220,
  PinC6 = 0x0240,
  PinC7 = 0x0280,
  PinD0 = 0x0301,
  PinD1 = 0x0302,
  PinD2 = 0x0304,
  PinD3 = 0x0308,
  PinD4 = 0x0310,
  PinD5 = 0x0320,
  PinD6 = 0x0340,
  PinD7 = 0x0380,
} pin_t;

#ifdef __cplusplus
extern "C" {
#endif
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 "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


hd44780.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() {
	return _microseconds;
}

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


void delay_ms(uint32_t ms) {
	return;
	until = system_ms() + ms;
	while (system_ms() < until);
	return;
	for (long int i = 0; i < 1000000; i++)
		asm("nop");
	asm("nop");
}

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>
uint32_t until;
#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

#ifndef _ssd1680_h
#define _ssd1680_h
#include "gpio.h"

typedef enum {
  DRIVER_CONTROL = 0x01,
  GATE_VOLTAGE = 0x03,
  SOURCE_VOLTAGE = 0x04,
  xxxDISPLAY_CONTROL = 0x07,
  INIT_PROGRAM  = 0x08,
  INIT_WRITE = 0x09,
  INIT_READ = 0x0A,
  BOOSTER_SOFT_START = 0x0C,
  GATE_SCAN_START = 0x0F,
  DEEP_SLEEP = 0x10,
  DATA_MODE = 0x11,
  SW_RESET = 0x12,
  HV_READY_DETECTION = 0x14,
  VCI_READY_DETECTION = 0x15,
  TEMP_CONTROL = 0x18,
  TEMP_WRITE = 0x1A,
  TEMP_READ = 0x1B,
  TEMP_WRITE_EXT = 0x1C,
  MASTER_ACTIVATE = 0x20,
  DISPLAY_UPDATE_CONTROL1 = 0x21,
  DISPLAY_UPDATE_CONTROL2 = 0x22,
  WRITE_RAM_BW = 0x24,
  READ_RAM = 0x25,
  WRITE_RAM_RED = 0x26,
  VCOM_SENSE = 0x28,
  VCOM_SENSE_DURATION = 0x29,
  VCOM_OTP = 0x2A,
  VCOM_CONTOL_WRITE = 0x2B,
  VCOM_WRITE = 0x2C,
  READ_OTP = 0x2D,
  READ_USER_ID = 0x2E,
  STATUS_BIT_READ = 0x2F,
  PROGRAM_WS_OTP = 0x30,
  LOAD_WS_OTP = 0x31,
  WRITE_LUT = 0x32,
  CRC_CALCULATION = 0x34,
  CRC_STATUS_READ = 0x35,
  PROGRAM_OTP_SELECTION = 0x36,
  DISPLAY_OPTION_WRITE = 0x37,
  USER_ID_WRITE = 0x38,
  OTP_PROGRAM_MODE = 0x39,
  xxxWRITE_DUMMY = 0x3A,
  xxxWRITE_GATELINE = 0x3B,
  WRITE_BORDER = 0x3C,
  END_OPTION = 0x3F,
  READ_RAM_OPTION = 0x41,
  SET_RAMXPOS = 0x44,
  SET_RAMYPOS = 0x45,
  AUTO_WRITE_RED_RAM = 0x46,
  AUTO_WRITE_BW_RAM = 0x47,
  SET_RAMXCOUNT = 0x4E,
  SET_RAMYCOUNT = 0x4F,
  NOP = 0xFF,
} ssd1680_command_t;


void ssd1680_enable(pin_t cs_pin, pin_t rs_pin);
void ssd1680_disable();
void ssd1680_set_pixel(uint16_t x, uint16_t y, uint16_t value);

#endif


ssd1680.h

#include "ssd1680.h"
#include "gpio.h"

static pin_t _cspin;
static pin_t _dcpin;



static void transmit_command(ssd1680_command_t cmd) {
  pin_reset(_dcpin);
  pin_reset(_cspin);
	spi_transfer8(cmd);
  pin_set(_cspin);
}

static void transmit_data(uint8_t data) {
  pin_set(_dcpin);
  pin_reset(_cspin);
	spi_transfer8(data);
  pin_set(_cspin);
}

static void transmit_data16(uint16_t data) {
  pin_set(_dcpin);
  pin_reset(_cspin);
	spi_transfer8((uint8_t)(data >> 8));
	spi_transfer8(data );
  pin_set(_cspin);
}

static void command(uint8_t cmd) {
	transmit_command(cmd);
}

static void command1(uint8_t cmd, uint8_t p1) {
	transmit_command(cmd);
	transmit_data(p1);
}

static void command2(uint8_t cmd, uint8_t p1, uint8_t p2) {
	transmit_command(cmd);
	transmit_data(p1);
	transmit_data(p2);
}

static void command3(uint8_t cmd, uint8_t p1, uint8_t p2, uint8_t p3) {
	transmit_command(cmd);
	transmit_data(p1);
	transmit_data(p2);
	transmit_data(p3);
}

static void command4(uint8_t cmd, uint8_t p1, uint8_t p2, uint8_t p3, uint8_t p4) {
	transmit_command(cmd);
	transmit_data(p1);
	transmit_data(p2);
	transmit_data(p3);
	transmit_data(p4);
}



void ssd1680_enable(pin_t cspin, pin_t dcpin) {
  _cspin = cspin;
  _dcpin = dcpin;
	delay_ms(1000);
  command(SW_RESET); // soft reset
  delay_ms(1000); // busy wait
  command3(DRIVER_CONTROL, 27, 1, 0);
  command1(DATA_MODE, 0x03); // Ram data entry mode
	command2(SET_RAMXPOS, 0, 0x0F);
	command4(SET_RAMYPOS, 0, 0, 0x27, 1);
	command2(DISPLAY_UPDATE_CONTROL1, 0, 0x80);
	command1(SET_RAMXCOUNT, 0);
  command2(SET_RAMYCOUNT, 0, 0);
	//send lut
	//command1(END_OPTION, 0x22);
  command1(GATE_VOLTAGE, 0x17); // Set gate voltage 
  command3(SOURCE_VOLTAGE, 0x41, 0x00, 0x32);   // Set source voltage

  command1(VCOM_WRITE, 0x36); // Vcom Voltage
  command1(WRITE_BORDER, 0x0F); // border color

	delay_ms(1000);
  //0xFE};

	//command2(SET_RAMXPOS, 0, 0x0f);
	//command4(SET_RAMYPOS, 0, 0, 0x27, 1);

	command(WRITE_RAM_BW);
	transmit_data(0xAA);
	transmit_data(0xAA);


	command1(DISPLAY_UPDATE_CONTROL2, 0xF4);
	command(MASTER_ACTIVATE);
	delay_ms(2000);
}

void ssd1680_set_pixel(uint16_t x, uint16_t y, uint16_t color) {
	uint8_t yh = y >> 8, yl = y & 0xff;
	uint8_t ch = (uint16_t)color >> 8, cl = (uint16_t)(color & 0xff);
	//command2(SET_RAMXPOS, x, x);
	//command4(SET_RAMYPOS, yh, yl, yh, yl);
	command(WRITE_RAM_BW);
	transmit_data(ch);
	transmit_data(cl);

	command1(DISPLAY_UPDATE_CONTROL2, 0xF7);
	command(MASTER_ACTIVATE);

}


ssd1680.c

#include "ili9341.h"
#include "gpio.h"
#include "spi.h"
#include <stdint.h>
#include <stdbool.h>

#define BIT(x) (1<<x)

pin_t _cspin;
pin_t _dcpin;

typedef enum {
	NOP = 0x00,
	SOFTWARE_RESET = 0x01,
	READ_INDENTIFICATION = 0x04,
	READ_DISPLAY_STATUS = 0x09,
	READ_DISPLAY_POWER_MODE = 0xa,
	READ_MEMORY_ACCESS_CONTROL = 0x0b,
	READ_DISPLAY_PIXEL_FORMAT = 0xc,
	READ_DISPLAY_IMAGE_FORMAT = 0xc,
	READ_SELF_DIAGNOSTIC = 0xF,
	//
	ENTER_SLEEP_MODE = 0x10,
	SLEEP_OUT = 0x11,
	PARTIAL_DISPLAY_MODE_ON = 0x12,
	NORMAL_DISPLAY_MODE_ON = 0x13,
	//
	DISPLAY_INVERSION_OFF = 0x20,
	DISPLAY_INVERSION_ON = 0x21,
	GAMMA_SET = 0x26,
	DISPLAY_OFF = 0x28,
	DISPLAY_ON = 0x29,
	COLUMN_ADDRESS_SET = 0x2a,
	PAGE_ADDRESS_SET = 0x2b,
	MEMORY_WRITE = 0x2c,
	COLOR_SET = 0x2d,
	MEMORY_READ = 0x2e,
	//
	PARTIAL_AREA = 0x30,
	VERTICAL_SCROLLING_DEFINITION = 0x33,
	TEARING_EFFECT_LINE_OFF = 0x34,
	TEARING_EFFECT_LINE_ON = 0x35 ,
	MEMORY_ACCESS_CONTROL = 0x36,
	VERTICAL_SCROLLING_START_ADDRESS = 0x37,
	IDLE_MODE_OFF = 0x38,
	IDLE_MODE_ON = 0x39,
	PIXEL_FORMAT_SET = 0x3A,
	WRITE_MEMORY_CONTINUE = 0x3C,
	READ_MEMORY_CONTINUE = 0x3D,
	//
	RGB_INTERFACE_SIGNAL_CONTROL = 0xB0,
	FRAME_RATE_CONTROL = 0xB1,
	FRAME_RATE_CONTROL2 = 0xB2,
	FRAME_RATE_CONTROL3 = 0xB3,
	DISPLAY_INVERSION_CONTROL = 0xB4,
	BLANKING_PORCH_CONTROL = 0xB5,
	DISPLAY_FUNCTION_CONTROL = 0xB6,
	ENTRY_MODE_SET = 0xB7,
	BACKLIGHT_CONTROL1 = 0xB8,
	BACKLIGHT_CONTROL2 = 0xB9,
	BACKLIGHT_CONTROL3 = 0xBA,
	BACKLIGHT_CONTROL4 = 0xBB,
	BACKLIGHT_CONTROL5 = 0xBC,
	BACKLIGHT_CONTROL6 = 0xBD,
	BACKLIGHT_CONTROL7 = 0xBE,
	BACKLIGHT_CONTROL8 = 0xBF,
	//
	POWER_CONTROL1 = 0xC0,
	POWER_CONTROL2 = 0xC1,
	VCOM_CONTROL1 = 0xC5,
	VCOM_CONTROL2 = 0xC7,
	//
	READ_ID1 = 0xDA,
	READ_ID2 = 0xDB,
	READ_ID3 = 0xDC,
	//
	POSITIVE_GAMMA_CORRECTION = 0xE0,
	NEGATIVE_GAMMA_CORRECTION = 0xE1,
	INTERFACE_CONTROL = 0xF6,
	// extended
	POWER_CONTROL_A = 0xCB,
	POWER_CONTROL_B = 0xCF,
	DRIVER_TIMING_CONTROL_A = 0xE8,
	DRIVER_TIMING_CONTROL_b = 0xEA,
	POWER_ON_SEQUENCE_CONTROL = 0xED,
	PUMP_RATIO_CONTROL = 0xF7
} ili9341_command_t;

// MEMORY_ACCESS_CONTROL 0x0b
#define MY 7 // row address order 0=top to bottom, 1=bottom to top
#define MX 6 // column addres order 0=left to right, 1=right to left
#define MV 5 // row/column exchange
#define ML 4 // vertical refresh order
#define BGR 3 // rgb/grb order
#define MH 2 // horizontal refresh order
// DISPLAY_FUNCTION_CONTROL 0xB6
#define PT0 0
#define PT1 1
#define PTG0 2
#define PTG1 3
//
#define ISC0 0
#define ISC1 1
#define ISC2 2
#define ISC3 3
#define ISC 0b00001111
#define SM 4
#define SS 5
#define GS 6
#define REV 7
//
#define NL 0b00111111


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

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

static void transmit_command(ili9341_command_t cmd) {
  pin_reset(_dcpin);
//  pin_reset(_cspin);
	spi_transfer8(cmd);
//  pin_set(_cspin);
}

static void transmit_data(uint8_t data) {
  pin_set(_dcpin);
//  pin_reset(_cspin);
	spi_transfer8(data);
//  pin_set(_cspin);
}

static void transmit_data16(uint16_t data) {
  pin_set(_dcpin);
//  pin_reset(_cspin);
	spi_transfer8((uint8_t)(data >> 8));
	spi_transfer8(data );
//  pin_set(_cspin);
}

static void command(uint8_t cmd) {
	transmit_command(cmd);
}

static void command1(uint8_t cmd, uint8_t p1) {
	transmit_command(cmd);
	transmit_data(p1);
}

static void command2(uint8_t cmd, uint8_t p1, uint8_t p2) {
	transmit_command(cmd);
	transmit_data(p1);
	transmit_data(p2);
}

static void command3(uint8_t cmd, uint8_t p1, uint8_t p2, uint8_t p3) {
	transmit_command(cmd);
	transmit_data(p1);
	transmit_data(p2);
	transmit_data(p3);
}

static void command4(uint8_t cmd, uint8_t p1, uint8_t p2, uint8_t p3, uint8_t p4) {
	transmit_command(cmd);
	transmit_data(p1);
	transmit_data(p2);
	transmit_data(p3);
	transmit_data(p4);
}

void ili9341_enable(pin_t cspin, pin_t dcpin) {
	_cspin = cspin;
	_dcpin = dcpin;
  pin_mode(_cspin, Output);
  pin_mode(_dcpin, Output);
	chip_select();
	command(SOFTWARE_RESET);
	//_delay_ms(50);
	command(DISPLAY_OFF);
	command1(POWER_CONTROL1, 0x23); // 4.60v
	command1(POWER_CONTROL2, 0x10); // ???
	command2(VCOM_CONTROL1, 0x2B, 0x2B); // 3.775V
	command1(VCOM_CONTROL2, 0xC0); // no offset voltage
	//command1(MEMORY_ACCESS_CONTROL, BIT(MX) | BIT(BGR));
	command2(VERTICAL_SCROLLING_START_ADDRESS, 0, 0);
	command1(PIXEL_FORMAT_SET, 0x55); // 16bit/px
	command2(FRAME_RATE_CONTROL, 0, 0x1B);
	command3(DISPLAY_FUNCTION_CONTROL, BIT(PTG1), BIT(REV) + 2, 0x27);
	// TODO: set gamma
	command(SLEEP_OUT);
	//_delay_ms(150);
	command(DISPLAY_ON);
	//_delay_ms(200);
	chip_deselect();
}

void ili9341_set_rotation(int rotation) {
	chip_select();
	switch (rotation) {
		case 0:
				command1(MEMORY_ACCESS_CONTROL, BIT(MX) | BIT(BGR));
				break;
		case 1:
				command1(MEMORY_ACCESS_CONTROL, BIT(MX) | BIT(MY) | BIT(MV) | BIT(BGR));
				break;
		case 2:
				command1(MEMORY_ACCESS_CONTROL, BIT(MY) | BIT(BGR));
				break;
		case 3:
				command1(MEMORY_ACCESS_CONTROL, BIT(MV) | BIT(BGR));
				break;
	}
	chip_deselect();
}

void ili9341_disable() {
	chip_select();
	command(DISPLAY_OFF);
	command(ENTER_SLEEP_MODE);
	chip_deselect();
}

void ili9341_set_pixel(uint16_t x, uint16_t y, uint16_t color) {
	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);
	chip_select();
	command4(COLUMN_ADDRESS_SET, xh, xl, xh, xl);
	command4(PAGE_ADDRESS_SET, yh, yl, yh, yl);
	command(MEMORY_WRITE);
	transmit_data(ch);
	transmit_data(cl);
	chip_deselect();
}

void ili9341_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(COLUMN_ADDRESS_SET, x >> 8, x & 0xFF, x2 >> 8, x2 & 0xFF);
	command4(PAGE_ADDRESS_SET, y >> 8, y & 0xFF, y2 >> 8, y2 & 0xFF);
	command(MEMORY_WRITE);
	for (int i = 0; i < w * h * 2 ; i++)
		transmit_data(0xAA);
	chip_deselect();
}

void ili9341_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(COLUMN_ADDRESS_SET, x >> 8, x & 0xFF, x2 >> 8, x2 & 0xFF);
	command4(PAGE_ADDRESS_SET, y >> 8, y & 0xFF, y2 >> 8, y2 & 0xFF);
	command(MEMORY_WRITE);
	for (int i = 0; i < w * h; i++) {
		transmit_data(color >> 8);
		transmit_data(color &0xFF);
	}
	chip_deselect();
}


ili9341.c

#ifndef _ili9341_h
#define _ili9341_h
#include "gpio.h"
#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif
void ili9341_enable(pin_t cspin, pin_t dcpin);
void ili9341_disable();
void ili9341_set_rotation(int rotation);
void ili9341_set_pixel(uint16_t x, uint16_t y, uint16_t color);
void ili9341_set_block(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t color);
void ili9341_write_block(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint8_t * data);
#ifdef __cplusplus
}
#endif
#endif


ili9341.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_
#include <stdint.h>
#include <stdbool.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 "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>

typedef struct {
  spi_dev_t spi;
  uint8_t spi_buffer[10];
  pin_t cs_pin;
  pin_t dc_pin;
  uint8_t dc_pin_state;
} chip_state_t;

static 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->dc_pin)
    chip->dc_pin_state = pin_read(chip->dc_pin);
  if (pin == chip->cs_pin) {
    if (value == LOW)
      spi_start(chip->spi, chip->spi_buffer, sizeof(chip->spi_buffer));
    else
      spi_stop(chip->spi);
  }
}

static void chip_spi_done(void *user_data, uint8_t *buffer, uint32_t count) {
  chip_state_t *chip = (chip_state_t*)user_data;
  //printf("count: %d\n", count);
  for (int i = 0; i < count; i++) {
    printf (chip->dc_pin_state == LOW ? "cmd" : "data");
    printf (" %02X\n", buffer[i]);
  }
  
  if (pin_read(chip->cs_pin) == LOW)
    spi_start(chip->spi, chip->spi_buffer, sizeof(chip->spi_buffer));
}

void chip_init(void) {
  chip_state_t *chip = malloc(sizeof(chip_state_t));
  chip->cs_pin = pin_init("CS", INPUT_PULLUP);
  chip->dc_pin = pin_init("DC", INPUT_PULLUP);
  const pin_watch_config_t watch_config = {
    .edge = BOTH,
    .pin_change = chip_pin_change,
    .user_data = chip,
  };
  pin_watch(chip->cs_pin, &watch_config);
  pin_watch(chip->dc_pin, &watch_config);
  const spi_config_t spi_config = {
    .sck = pin_init("CLK", INPUT),
    .mosi = pin_init("MOSI", INPUT),
    .miso = NO_PIN,
    .done = chip_spi_done,
    .user_data = chip,
  };
  chip->spi = spi_init(&spi_config);
}
