README.md

diagram.json

#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() {
	cli();
	uint64_t v = _microseconds;
	sei();
	return v;
}

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

void delay_ms(uint32_t ms) {
	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 uart_handler_t _handler;

void _uart_enable(uint32_t bitrate, 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_rx)
		UCSR0B |= _BV(RXEN0) | _BV(RXCIE0);
	sei();
}

void uart_enable(uint32_t bitrate, uart_handler_t handler) {
	_handler = handler;
	_uart_enable(bitrate, true);
}

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

void uart_enable_rx_only(uint32_t bitrate, uart_handler_t handler) {
	_handler = handler;
	_uart_enable(bitrate, true);
}

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

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

#if defined (__AVR_ATmega2560__)
ISR(USART0_RX_vect) {
#else
ISR(USART_RX_vect) {
#endif
	uint8_t ch = UDR0;
	if (_handler)
		_handler(ch);
}


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 500
#endif

typedef void(*uart_handler_t)(uint8_t);

#ifdef __cplusplus
extern "C" {
#endif
void uart_enable(uint32_t bitrate, uart_handler_t handler);
void uart_enable_tx_only(uint32_t bitrate);
void uart_enable_rx_only(uint32_t bitrate, uart_handler_t handler);
void uart_disable();
bool uart_tx_buffer_is_empty();
void uart_write(uint8_t * data, uint8_t len);
void uart_print(uint8_t * str);
#ifdef __cplusplus
}
#endif
#endif


uart.h

#include "system.h"
#include "gpio.h"
#include "uart.h"
#include <stdio.h>

static char buf[100];
uint32_t stamp;

void rxhandler(uint8_t ch) {
	sprintf(&buf[0], "ch: %d\n", ch);
	uart_print(buf);
}

void setup() {
	uart_enable(9600, rxhandler);
	uart_print("start\n");
}


void loop() {
	uint32_t now = system_ms();
	if (system_ms() % 1000 < stamp % 1000) {
  	sprintf(&buf[0], "%d\n", system_ms());
		uart_print(buf);
	}
	stamp = now;
}


main.cpp

#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
