diagram.json

#include "system.h"
#include "ili9327.h"

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

void setup() {
	ili9327_enable(PinB0, PinB1, PinB2, PinB3, PortD);
	ili9327_set_pixel(10, 10, 0xFFFF);
	//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 rs_pin;
  pin_t wr_pin;
  pin_t rd_pin;
  pin_t rst_pin;
  pin_t db0_pin;
  pin_t db1_pin;
  pin_t db2_pin;
  pin_t db3_pin;
  pin_t db4_pin;
  pin_t db5_pin;
  pin_t db6_pin;
  pin_t db7_pin;
  /* 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];
  // data buffer
  uint8_t data_buf[2];
  uint8_t data_index;

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

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);
  chip->rs_pin = pin_init("RS", INPUT);
  chip->wr_pin = pin_init("WR", INPUT);
  chip->rd_pin = pin_init("RD", INPUT);
  chip->rst_pin = pin_init("RST", INPUT_PULLUP);
  chip->db0_pin = pin_init("DB0", INPUT);
  chip->db1_pin = pin_init("DB1", INPUT);
  chip->db2_pin = pin_init("DB2", INPUT);
  chip->db3_pin = pin_init("DB3", INPUT);
  chip->db4_pin = pin_init("DB4", INPUT);
  chip->db5_pin = pin_init("DB5", INPUT);
  chip->db6_pin = pin_init("DB6", INPUT);
  chip->db7_pin = pin_init("DB7", INPUT);

  pin_watch(chip->cs_pin, &watch_config);
  pin_watch(chip->rs_pin, &watch_config);
  pin_watch(chip->wr_pin, &watch_config);
  pin_watch(chip->rd_pin, &watch_config);
  pin_watch(chip->rst_pin, &watch_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
}

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("command %02X", chip->command_code);
  for (int i = 0; i < chip->command_size; i++)
    printf(" %02X", chip->command_buf[i]);
  printf("\n");
  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: {
      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) {
  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 process(void * user_data) {
  chip_state_t *chip = (chip_state_t*)user_data;
  //uint8_t * buffer = chip->data_buffer;
  uint8_t count = 0;//chip->data_index;
  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));
  }
}
*/


void write_ram(chip_state_t *chip, uint16_t value) {
  printf("ram %02X\n", value);
  uint32_t color;
  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(value);
  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;
      }
    }
  }
}





uint8_t port_read(void * user_data) {
  chip_state_t * chip = (chip_state_t *)user_data;
  uint8_t byte = (pin_read(chip->db0_pin) ? 0x01 : 0)
      | (pin_read(chip->db1_pin) ? 0x02 : 0)
      | (pin_read(chip->db2_pin) ? 0x04 : 0)
      | (pin_read(chip->db3_pin) ? 0x08 : 0)
      | (pin_read(chip->db4_pin) ? 0x10 : 0)
      | (pin_read(chip->db5_pin) ? 0x20 : 0)
      | (pin_read(chip->db6_pin) ? 0x40 : 0)
      | (pin_read(chip->db7_pin) ? 0x80 : 0);
      return byte;
}

void chip_pin_change(void * user_data, pin_t pin, uint32_t value) {
  chip_state_t * chip = (chip_state_t *)user_data;
  // CS pin logic
  if (pin == chip->cs_pin) {
    if (value == LOW) {
      chip->command_size = 0;
      chip->command_index = 0;
    }
  }

  if (pin == chip->wr_pin && value == HIGH) {
    if (pin_read(chip->cs_pin) == LOW && pin_read(chip->rd_pin) == HIGH) {
      uint8_t data = port_read(chip);
      if (chip->mode == MODE_COMMAND) {
        chip->command_code = data;
        chip->command_size = command_args_size(data);
        chip->command_index = 0;
        if (!chip->command_size)
          execute_command(chip);
      } else {
        if (chip->ram_write) {
          chip->data_buf[chip->data_index++] = data;
          if (chip->data_index == 2) {
            uint16_t col = (chip->data_buf[0] << 8) | chip->data_buf[0];
            chip->data_index = 0;
            write_ram(chip, col);
          }
        } else {
          chip->command_buf[chip->command_index++] = data;
          if (chip->command_size == chip->command_index)
            execute_command(chip);
        }
      }

  /*    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);*/


      //parse_buffer(chip);
    }
  }

  // Handle RS pin logic
  if (pin == chip->rs_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) {
    chip_reset(chip);
  }
}


ili9327.chip.c

ILI9327 [240x320]

ili9327.chip.json

#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 "ili9327.h"
#include "system.h"
#include "gpio.h"
#include <stdint.h>
#include <stdbool.h>

static pin_t _cspin;
static pin_t _rspin;
static pin_t _wrpin;
static pin_t _rdpin;
static port_t _port;

typedef enum {
	// system commands
	NOP                        = 0x00,
	SOFT_RESET                 = 0x01, // Sowtware Reset
	GET_RED_CHANNEL            = 0x06, 
	GET_GREEN_CHANNEL          = 0x07,
	GET_BLUE_CHANNEL           = 0x08,
	GET_POWER_MODE             = 0x0A,
	GET_ADDRESS_MODE           = 0x0B,
	GET_PIXEL_FORMAT           = 0x0C,
	GET_DISPLAY_MODE           = 0x0D,
	GET_SIGNAL_MODE            = 0x0E,
	GET_DIAGNOSTIC_RESULT      = 0x0F,
	ENTER_SLEEP_MODE           = 0x10,
	EXIT_SLEEP_MODE            = 0x11,
	ENTER_PARTIAL_MODE         = 0x12,
	ENTER_NORMAL_MODE          = 0x13,
	EXIT_INVERT_MODE           = 0x20,
	ENTER_INVERT_MODE          = 0x21,
	SET_DISPLAY_OFF            = 0x28,
	SET_DISPLAY_ON             = 0x29,
	SET_COLUMN_ADDRESS         = 0x2A,
	SET_PAGE_ADDRESS           = 0x2B,
	WRITE_MEMORY_START         = 0x2C,
	READ_MEMORY_START          = 0x2E,
	SET_PARTIAL_AREA           = 0x30,
	SET_SCROLL_AREA            = 0x33,
	SET_TEAR_OFF               = 0x34,
	SET_TEAR_ON                = 0x35,
	SET_ADDRESS_MODE           = 0x36,
	SET_SCROLL_START           = 0x37,
	EXIT_IDLE_MODE             = 0x38,
	ENTER_IDLE_MODE						 = 0x39,
	SET_PIXEL_FORMAT           = 0x3A,
	WRITE_MEMORY_CONTINUE      = 0x3C,
	READ_MEMORY_CONTINUE       = 0x3E,
	SET_TEAR_SCANLINE          = 0x44,
	GET_SCANLINE               = 0x45,
	WRITE_DISPLAY_BRIGHTNESS   = 0x51,
	READ_DISPLAY_BRIGHTNESS    = 0x52,
	WRITE_CTRL_DISPLAY				 = 0x53,
	READ_CTRL_DISPLAY          = 0x54,
	WRITE_CONTENT_ADAPTIVE_BRIGHTNESS_CONTROL = 0x55,
	READ_CONTENT_ADAPTIVE_BRIGHTNESS_CONTROL = 0x56,
	WRITE_CABC_MINIMUM_BRIGHTNESS = 0x5E,
	READ_CABC_MINIMUM_BRIGHTNESS  = 0x5F,

	READ_DDB_START             = 0xA1,
	COMMAND_ACCRESS_PROTECT    = 0xB0,
	LOW_POWER_MODE_CONTROL     = 0xB1,
	FRAME_MEMORY_ACCESS_AND_INTERFACE_SETTING = 0xB3,
	DISPLAY_MEMORY_AND_FRAME_MEMORY_WRITE_SETTING = 0xB4,
	SUB_PANEL_CONTROL_REGISTER = 0xB5,
	BACKLIGHT_CONTROL_1        = 0xB8,
	BACKLIGHT_CONTROL_2        = 0xB9,
	BACKLIGHT_CONTROL_3        = 0xBA,
	BACKLIGHT_CONTROL_4        = 0xBB,
	BACKLIGHT_CONTROL_5        = 0xBC,
	BACKLIGHT_CONTROL_6        = 0xBD,
	BACKLIGHT_CONTROL_7        = 0xBE,
	BACKLIGHT_CONTROL_8        = 0xBF,
	PANEL_DRIVING_SETTING      = 0xC0,
	DISPLAY_TIMING_SETTING_NORMAL_PARTIAL_MODE = 0xC1,
	DISPLAY_TIMING_SETTING_IDLE_MODE = 0xC3,
	SOURCE_VCOM_GATE_TIMING_SETTING = 0xC4,

	FRAME_RATE_CONTROL         = 0xC5,
	INTERACE_CONTROL					 = 0xC6,
	GAMMA_SETTING              = 0xC8,
	GAMMA_SETTING_BLUE_RED_COLOR = 0xC9,
	POWER_SETTING              = 0xD0,
	VCOM_CONTROL               = 0xD1,
	POWER_SETTING_NORMAL_MODE  = 0xD2,
	POWER_SETTING_PARTIAL_MODE = 0xD3,
	POWER_SETTING_IDLE_MODE    = 0xD4,

	NV_MEMORY_WRITE            = 0xE0,
	NV_MEMORY_CONTROL          = 0xE1,
	NV_MEMORY_STATUS_READ      = 0xE2,
	NV_MEMORY_PROTECTION       = 0xE3,
	THREE_GAMMA_FUNCTION_CONTROL = 0xEA,
	DEVICE_CODE_READ           = 0xEF,
} ili9327_command_t;

#define MX  0x80 // row address order 0=top to bottom, 1=bottom to top
#define MY  0x40 // column addres order 0=left to right, 1=right to left
#define MV  0x20 // row/column exchange
#define ML  0x10 // vertical refresh order
#define BGR 0x08 // rgb/grb order
#define MH  0x04 // horizontal refresh order


static void write(uint8_t value) {
	pin_reset(_wrpin);
	port_write_byte(_port, value);
	pin_set(_wrpin);
}

static void command(uint8_t cmd) {
	pin_reset(_rspin);
	write(cmd);
}

static void write_data(uint8_t data) {
	pin_set(_rspin);
	write(data);
}

static void command1(uint8_t cmd, uint8_t p1) {
	pin_reset(_rspin);
	write(cmd);
	pin_set(_rspin);
	write(p1);
}

static void command2(uint8_t cmd, uint8_t p1, uint8_t p2) {
	pin_reset(_rspin);
	write(cmd);
	pin_set(_rspin);
	write(p1);
	write(p2);
}

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

static void command4(uint8_t cmd, uint8_t p1, uint8_t p2, uint8_t p3, uint8_t p4) {
	pin_reset(_rspin);
	write(cmd);
	pin_set(_rspin);
	write(p1);
	write(p2);
	write(p3);
	write(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(_rspin);
	write(cmd);
	pin_set(_rspin);
	write(p1);
	write(p2);
	write(p3);
	write(p4);
	write(p5);
	write(p6);
}

void ili9327_set_rotation(int rotation) {
	pin_reset(_cspin);
	switch (rotation) {
		case 0:
				command1(SET_ADDRESS_MODE, 0);
				break;
		case 1:
				command1(SET_ADDRESS_MODE, MX | MV);
				break;
		case 2:
				command1(SET_ADDRESS_MODE, MY);
				break;
		case 3:
				command1(SET_ADDRESS_MODE, MY | MV);
				break;
	}
	pin_set(_cspin);
}

void ili9327_enable(pin_t cspin, pin_t rspin, pin_t wrpin, pin_t rdpin, port_t port) {
	_cspin = cspin;
	_rspin = rspin;
	_wrpin = wrpin;
	_rdpin = rdpin;
	_port = port;
  pin_mode(_cspin, Output);
	pin_set(_cspin);
  pin_mode(_rspin, Output);
  pin_mode(_wrpin, Output);
  pin_mode(_rdpin, Output);
	port_mode(_port, Output);
	pin_set(_rspin);
	pin_set(_wrpin);
	pin_set(_rdpin);
	pin_reset(_cspin);
	command(SOFT_RESET);
	delay_ms(50);
	command(EXIT_SLEEP_MODE);
	delay_ms(500);
//	command3(FRAME_RATE_CONTROL,
//      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(EXIT_INVERT_MODE);
	command1(SET_PIXEL_FORMAT, 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(SET_DISPLAY_ON);
	delay_ms(100);
	ili9327_set_rotation(0);
	pin_set(_cspin);
}

void ili9327_disable() {
	pin_reset(_cspin);
	command(SET_DISPLAY_OFF);
	command(ENTER_SLEEP_MODE);
	pin_set(_cspin);
}

void ili9327_set_pixel(uint16_t x, uint16_t y, uint16_t color) {
	pin_reset(_cspin);
	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(SET_COLUMN_ADDRESS, xh, xl, xh, xl);
	command4(SET_PAGE_ADDRESS, yh, yl, yh, yl);
	command(WRITE_MEMORY_START);
	write_data(ch);
	write_data(cl);
	pin_set(_cspin);
}

void ili9327_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;
	pin_reset(_cspin);
	command4(SET_COLUMN_ADDRESS, x >> 8, x & 0xFF, x2 >> 8, x2 & 0xFF);
	command4(SET_PAGE_ADDRESS, y >> 8, y & 0xFF, y2 >> 8, y2 & 0xFF);
	command(WRITE_MEMORY_START);
	for (int i = 0; i < w * h * 2; i++)
		write_data(data[i]);
	pin_set(_cspin);	
}

void ili9327_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;
	pin_reset(_cspin);
	command4(SET_COLUMN_ADDRESS, x >> 8, x & 0xFF, x2 >> 8, x2 & 0xFF);
	command4(SET_PAGE_ADDRESS, y >> 8, y & 0xFF, y2 >> 8, y2 & 0xFF);
	command(WRITE_MEMORY_START);
	for (int i = 0; i < w * h; i++) {
		write_data(color >> 8);
		write_data(color & 0xFF);
	}
	pin_set(_cspin);
}


ili9327.c

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

#ifdef __cplusplus
extern "C" {
#endif

void ili9327_enable(pin_t cspin, pin_t rspin, pin_t wrpin, pin_t rdpin, port_t port);
void ili9327_disable();
void ili9327_set_rotation(int rotation);
void ili9327_set_pixel(uint16_t x, uint16_t y, uint16_t color);
void ili9327_set_block(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t color);
void ili9327_write_block(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint8_t * data);

#ifdef __cplusplus
}
#endif
#endif


ili9327.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
