#pragma optimize("", off)

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

void setup() {
	pin_mode(PinC0, Output);
	pin_set(PinC0);
	spi_enable();
	st7735_enable(PinB2, PinB1);
	st7735_set_pixel(0, 0, 0xFFFF);
}

void loop() {
	//pin_toggle(PinC0);
	//delay_ms(10);
	//return;
	//if (system_ms() % 1000 < 500)
		pin_reset(PinC0);
		delay_ms(500);
	//else
		pin_set(PinC0);
		delay_ms(500);
}


main.c

diagram.json

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



libraries.txt

ST7735S [128x160]

st7735.chip.json

#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

spilog

spilog.chip.json

#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++) {
    if (buffer[i] == 0xAA)
      continue;
    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);
}


spilog.chip.c

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

void pin_toggle(pin_t pin) {
	volatile uint8_t * port = (volatile uint8_t *)(0x20 + (2 + 3 * pin_port(pin)));
	if (pin_read(pin))
		pin_reset(pin);
	else
		pin_set(pin);
}

bool pin_read(pin_t pin) {
	volatile uint8_t * port = (volatile uint8_t *)(0x20 + (2 + 3 * pin_port(pin)));
  return *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));};
void pin_toggle(pin_t pin);
bool pin_read(pin_t pin);
#ifdef __cplusplus
}
#endif
#endif


gpio.h

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

static volatile uint64_t _microseconds = 0;
static volatile uint32_t _milliseconds = 0;

ISR(TIMER0_OVF_vect) {
	_microseconds += 1024;
	_milliseconds += 1;// (uint32_t)(_microseconds / 1000);
}

uint64_t system_us() {
	return _microseconds;
}

uint32_t system_ms() {
	cli();
	uint32_t v = _milliseconds;
	sei();
	return v;
}


void delay_ms(uint32_t ms) {
	uint32_t until = system_ms() + ms;
	while (system_ms() < until) {
		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>

#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 "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 "st7735.h"
#include "gpio.h"
#include "spi.h"
#include "system.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 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_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(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
		0xEE);//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, 0);//0x7F);
	//command4(ROW_ADDRESS_SET, 0, 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, 0);//BIT(ML) | BIT(MX) | BIT(MY));//| BIT(BGR));
	command(NORMAL_DISPLAY_MODE_ON);
	command(DISPLAY_ON);
	delay_ms(100);
	chip_deselect();
}

void st7735_disable() {
	chip_select();
	command(DISPLAY_OFF);
	command(SLEEP_IN);
	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(COLUMN_ADDRESS_SET, xh, xl, xh, xl);
	command4(ROW_ADDRESS_SET, yh, yl, yh, yl);
	command(MEMORY_WRITE);
	write_data(ch);
	write_data(cl);
	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_pixel(uint16_t x, uint16_t y, uint16_t color);
#ifdef __cplusplus
}
#endif
#endif
