diagram.json

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

void pin_mode(pin_t pin, pin_mode_t mode) {
	volatile uint8_t * port = (volatile uint8_t *)(0x20 + (2 + 3 * pin_port(pin)));
	volatile uint8_t * ddr = (volatile uint8_t *)(0x20 + (1 + 3 * pin_port(pin)));
  //uint8_t pin_mask = pin & 0xf;
	switch (mode) {
		case Input:
			*port &= ~pin_mask(pin);
			break;
		case InputPullup:
      *ddr &= ~pin_mask(pin);
      *port |= pin_mask(pin);
			break;
		case Output:
			*ddr |= pin_mask(pin);
			break;
	}
}

void pin_set(pin_t pin) {
	volatile uint8_t * port = (volatile uint8_t *)(0x20 + (2 + 3 * pin_port(pin)));
  *port |= pin_mask(pin);
}

void pin_reset(pin_t pin) {
	volatile uint8_t * port = (volatile uint8_t *)(0x20 + (2 + 3 * pin_port(pin)));
  *port &= ~pin_mask(pin);
}


gpio.c

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

typedef enum {
	PortA = 1,
	PortB,
	PortC,
	PortD,
} 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,
	PinSCK = PinB5,
	PinMOSI = PinB4,
	PinSS = PinB2,
	P0 = PinD0,
	P1 = PinD1,
	P2 = PinD2,
	P3 = PinD3,
	P4 = PinD4,
	P5 = PinD5,
	P6 = PinD6,
	P7 = PinD7,
	P8 = PinB0,
	P9 = PinB1,
	P10 = PinB2,
	P11 = PinB3,
	P12 = PinB4,
	P13 = PinB5,
	A0 = PinC0,
	A1 = PinC1,
	A2 = PinC2,
	A3 = PinC3,
	A4 = PinC4,
	A5 = PinC5,
 } pin_t;

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

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

#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);
inline void pin_write(pin_t pin, bool value) {(value ? pin_set(pin) : pin_reset(pin));};
#ifdef __cplusplus
}
#endif
#endif


gpio.h

#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 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);
	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);
}

void ili9341_set_rotation(int rotation) {
	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;
	}
}

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

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);
	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);
}

void ili9341_v(uint16_t x, uint16_t y, uint8_t h, uint8_t * data, uint16_t len) {
	uint8_t xh = x >> 8, xl = x & 0xff;
	uint8_t yh = y >> 8, yl = y & 0xff;
	uint16_t x1 = x + 1;
	uint16_t y1 = y + h;
	uint8_t x1h = x1 >> 8, x1l = x1 & 0xff;
	uint8_t y1h = y1 >> 8, y1l = y1 & 0xff;
	command4(COLUMN_ADDRESS_SET, xh, xl, xh, xl);
	command4(PAGE_ADDRESS_SET, yh, yl, y1h, y1l);
	command(MEMORY_WRITE);
	for (int i = 0; i < len * h; i++)
		transmit_data(data[i]);
}


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_v(uint16_t x, uint16_t y, uint8_t h, uint8_t * data, uint16_t len);
#ifdef __cplusplus
}
#endif
#endif


ili9341.h

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

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

void spi_disable() {
	SPCR = 0;
	pin_mode(PinSCK, Input);
	pin_mode(PinMOSI, 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 <avr/io.h>
#include <avr/interrupt.h>
#include "system.h"
#include <stdint.h>

static volatile uint64_t _microseconds;

ISR(TIMER0_OVF_vect) {
	_microseconds += 1024;
}

inline uint64_t system_us() {
	return _microseconds;
}

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

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

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 <avr/io.h>
#include <avr/interrupt.h>
#include <string.h>
#include <stdbool.h>
#include "uart.h"

static uint8_t tx_buffer[UART_TX_BUFFER_SIZE + 1];
static volatile uint8_t tx_buffer_head;
static volatile uint8_t tx_buffer_tail;

static volatile uint8_t rx_buffer[UART_RX_BUFFER_SIZE + 1];
static volatile uint8_t rx_buffer_head;
static volatile uint8_t rx_buffer_tail;

void _uart_enable(uint32_t bitrate, bool enable_tx, bool enable_rx) {
	// SEL0=0 UPM0=0 USBS0=0 UCSZ0=3 async, no parity, 1 stop bit, 8 bit size
	UCSR0C |= _BV(UCSZ00) | _BV(UCSZ01);
	uint32_t b = (F_CPU / (bitrate * 16UL)) - 1;
	UBRR0L = b;
	UBRR0H = b >> 8;
	//if (enable_tx)
	//	UCSR0B |= _BV(TXEN0);
	if (enable_rx)
		UCSR0B |= _BV(RXEN0) | _BV(RXCIE0);
	sei();
}

void uart_enable(uint32_t bitrate) {
	_uart_enable(bitrate, true, true);
}

void uart_enable_tx_only(uint32_t bitrate) {
	_uart_enable(bitrate, true, false);
}

void uart_enable_rx_only(uint32_t bitrate) {
	_uart_enable(bitrate, false, true);
}

void uart_disable() {
	UCSR0B = 0;
	UCSR0C = 0;
}

bool uart_tx_buffer_is_empty() {
	return (tx_buffer_head == tx_buffer_tail);
}

void uart_write(uint8_t * data, uint8_t len) {
	bool empty = (tx_buffer_head == tx_buffer_tail);
	for (int i = 0; i < len; i++) {
		uint8_t next = (tx_buffer_head < UART_TX_BUFFER_SIZE ? tx_buffer_head + 1 : 0);
		tx_buffer[tx_buffer_head] = data[i];
		tx_buffer_head = next;
	}
	if (empty)
		UCSR0B |= _BV(TXEN0) | _BV(UDRIE0);
}

void uart_print(uint8_t * data) {
	uart_write(data, strlen((char *)data));
}

#if defined (__AVR_ATmega2560__)
ISR(USART0_UDRE_vect) {
#else
ISR(USART_UDRE_vect) {
#endif
	if (tx_buffer_head != tx_buffer_tail) {
		uint8_t next = (tx_buffer_tail < UART_TX_BUFFER_SIZE ? tx_buffer_tail + 1 : 0);
		UDR0 = tx_buffer[tx_buffer_tail];
		tx_buffer_tail = next;
	} else
		UCSR0B &= ~_BV(TXEN0);
		//UCSR0B &= ~_BV(UDRIE0);
}

bool uart_data_is_available() {
	return (rx_buffer_head != rx_buffer_tail);
}

uint8_t uart_read() {
		if (rx_buffer_head == rx_buffer_tail)
			return 0;
		uint8_t next = (rx_buffer_tail < UART_RX_BUFFER_SIZE - 1 ? rx_buffer_tail + 1 : 0);
		uint8_t ch = rx_buffer[rx_buffer_tail];
		rx_buffer_tail = next;
		return ch;
}

#if defined (__AVR_ATmega2560__)
ISR(USART0_RX_vect) {
#else
ISR(USART_RX_vect) {
#endif
	uint8_t ch = UDR0;
	uint8_t next = (rx_buffer_head < UART_RX_BUFFER_SIZE - 1 ? rx_buffer_head + 1 : 0);
	if (next == rx_buffer_tail)
		return;
	rx_buffer[rx_buffer_head] = ch;
	rx_buffer_head = next;
}


uart.c

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

#if !defined(UART_TX_BUFFER_SIZE)
#define UART_TX_BUFFER_SIZE 300
#endif
#if !defined(UART_RX_BUFFER_SIZE)
#define UART_RX_BUFFER_SIZE 10
#endif

#ifdef __cplusplus
extern "C" {
#endif
void uart_enable(uint32_t bitrate);
void uart_enable_tx_only(uint32_t bitrate);
void uart_enable_rx_only(uint32_t bitrate);
void uart_disable();

bool uart_tx_buffer_is_empty();
void uart_write(uint8_t * data, uint8_t len);
void uart_print(uint8_t * str);

bool uart_data_is_available();
uint8_t uart_read();
#ifdef __cplusplus
}
#endif
#endif


uart.h


#include "system.h"
#include "gpio.h"
#include "spi.h"
#include "st7735.h"
#include <stdio.h>


void setup() {
	spi_enable();
	st7735_enable(PinB2, PinB1);
	st7735_set_pixel(0, 0, 0xFFFF);
}


void loop() {
}


main.cpp

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

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

static pin_t _cspin;
static pin_t _dcpin;

typedef enum {
	NOP = 0x00,
	SOFTWARE_RESET = 0x01,
	READ_DISPLAY_ID = 0x04,
	READ_DISPLAY_STATUS = 0x09,
	READ_DISPLAY_POWER_MODE = 0xA,
	READ_MEMORY_ACCESS_CONTROL = 0x0B,
	READ_DISPLAY_PIXEL_FORMAT = 0xC,
	READ_DISPLAY_IMAGE_FORMAT = 0xD,
	READ_DISPLAY_SIGNAL_MODE = 0x0E,
	READ_SELF_DIAGNOSTIC = 0xF,
	//
	SLEEP_IN = 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,
	ROW_ADDRESS_SET = 0x2b,
	MEMORY_WRITE = 0x2c,
	COLOR_SETTING = 0x2d,
	MEMORY_READ = 0x2e,
	//
	PARTIAL_AREA = 0x30,
	SCROLL_AREA_SET = 0x33,
	TEARING_EFFECT_LINE_OFF = 0x34,
	TEARING_EFFECT_LINE_ON = 0x35 ,
	MEMORY_ACCESS_CONTROL = 0x36,
	VERTICAL_SCROLL_START_ADDRESS = 0x37,
	IDLE_MODE_OFF = 0x38,
	IDLE_MODE_ON = 0x39,
	INTERFACE_PIXEL_FORMAT = 0x3A,
	//
	FRAME_RATE_CONTROL = 0xB1,
	FRAME_RATE_CONTROL2 = 0xB2,
	FRAME_RATE_CONTROL3 = 0xB3,
	DISPLAY_INVERSION_CONTROL = 0xB4,
	//
	POWER_CONTROL1 = 0xC0,
	POWER_CONTROL2 = 0xC1,
	POWER_CONTROL3 = 0xC2,
	POWER_CONTROL4 = 0xC3,
	POWER_CONTROL5 = 0xC4,
	VCOM_CONTROL1 = 0xC5,
	VCOM_OFFSET_CONTROL = 0xC7,
	//
	WRITE_ID2_VALUE = 0xD1,
	WRITE_ID3_VALUE = 0xD2,
	NVM_CONTROL_STATUS = 0xD9,
	READ_ID1_VALUE = 0xDA,
	READ_ID2_VALUE = 0xDB,
	READ_ID3_VALUE = 0xDC,
	NVM_READ_COMMAND = 0xDE,
	NVM_WRITE_COMMAND = 0xDF,
	//
	POSITIVE_GAMMA_CORRECTION = 0xE0,
	NEGATIVE_GAMMA_CORRECTION = 0xE1,
	//
	GATE_PUMP_CLOCK_FREQUENCY = 0xFC,
} st7735_command_t;

// MEMORY_ACCESS_CONTROL
#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_INVERSION_CONTROL 0xB4
#define NLC 0
#define NLB 1
#define NLA 2

static void transmit_command(st7735_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 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);
}

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

void st7735_enable(pin_t cspin, pin_t dcpin) {
	_cspin = cspin;
	_dcpin = dcpin;
  pin_mode(_cspin, Output);
	pin_set(_cspin);
  pin_mode(_dcpin, Output);
//	command(SOFTWARE_RESET);
	//delay_ms(50);
//	command(SLEEP_OUT);
	//delay_ms(500);
	command3(FRAME_RATE_CONTROL,
      1,
      0x2C,
      0x2D);
	//_delay_ms(10);
	command3(FRAME_RATE_CONTROL2,
      1,
      0x2C,
      0x2D);
	command6(FRAME_RATE_CONTROL3,
    1, 0x2C, 0x2D,
    1, 0x2C, 0x2D);
  
  command1(DISPLAY_INVERSION_CONTROL, 7);

	command3(POWER_CONTROL1,
		0xA2, // avdd=5v, gvdd=4.6v
		0x02, // gvcl=-4.6v
		0x84); // mode=auto, vrhp5,vrhn5=0

	//_delay_ms(10);
	command1(POWER_CONTROL2,
			0xC5); // vgh25=2.4v vghbt=1(vgh=3*avdd-0.5) vgh=14.5v vgl=-10v

//	command2(POWER_CONTROL3, // opamp curent in normal/full mode
//		0x0A, // ap=small sap=medium-low
//		0x00); // boost frequency
//	command2(POWER_CONTROL4, // opamp current in idle/8-colors mode
//		0x8A, // ap=small sap=medium-low
//		0x2A); // boost frequency
//	command2(POWER_CONTROL5, // opamp current in partial/full-color mode
//		0x8A, // ap=small sap=medium-low
//		0x2A); // boost frequency

	//command1(VCOM_CONTROL1, 0x0E); // -0.775

	//command(DISPLAY_INVERSION_OFF);

//	command1(INTERFACE_PIXEL_FORMAT, 0x05); // 16bit/px

	command4(COLUMN_ADDRESS_SET, 0, 0, 0, 0x7F);
	command4(ROW_ADDRESS_SET, 0, 0, 0, 0x9F);

	// 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

	command1(MEMORY_ACCESS_CONTROL, 0xC0);//BIT(MX) | BIT(MY) | BIT(BGR));
	//command(NORMAL_DISPLAY_MODE_ON);
	command(DISPLAY_ON);
	delay_ms(200);
}

void st7735_disable() {
	command(DISPLAY_OFF);
	command(SLEEP_IN);
}

void st7735_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);
	command4(COLUMN_ADDRESS_SET, xh, xl, xh , xl );
	command4(ROW_ADDRESS_SET, yh, yl, yh, yl);
	command(MEMORY_WRITE);
	transmit_data(ch);
	transmit_data(cl);
}


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_pixel(uint16_t x, uint16_t y, uint16_t color);
#ifdef __cplusplus
}
#endif
#endif


st7735.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);
}
