diagram.json

#include "system.h"
#include "hd44780.h"

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

void setup() {
	hd44780_enable(PinB2, PinB1, PinB0, 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);


}


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

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
