diagram.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;

#if defined (__AVR_ATtiny85__)
#define GPIO(x) ((gpio_t *)(0x20 + 0x13 + 3	* x))
#elif defined (__AVR_ATmega328P__)
#define GPIO(x) ((gpio_t *)(0x20 + 3	* x))
#endif

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 (port_t)(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 <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
#if defined (TIMSK0)
	TIMSK0 |= _BV(TOIE0);
#else
	TIMSK |= _BV(TOIE0);
#endif
}

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

void ws2812b_write(pin_t pin, uint8_t * data, uint16_t len);


ws2812b.h

#include <avr/io.h>

#define __SFR_OFFSET 0

.global ws2812b_write

ws2812b_write:
	mov   r28, r24     
	mov		r29, r24      ; r29 = port
	andi  r28, 0x0F     ; r28 = pin
	lsr   r29
	lsr   r29
	lsr   r29
	lsr   r29
	movw	r26, r22			;r26:27 = X = *data
	movw	r24, r20			;r24:25 = len

; make mask out of r28 to r30 and r31
	inc		r28
	ldi		r30, 0x01
mask:
	lsl		r30
	dec		r28
	brne	mask
	lsr   r30
	mov   r31, r30
	com		r31
; put PORTX address into Y (r28:29)
	ldi   r23, 0
	ldi   r22, 0x32
	mov		r21, r29
	inc   r21
mull:
	subi  r22, -3
	dec   r21
	brne  mull
	movw	r28, r22

	in		r22, SREG
	cli

	ld    r20, Y
	mov   r21, r20
	or    r20, r30 ;our '1' output
	and   r21, r31 ;our '0' output
	ldi		r19, 7				;7 bit counter (8th bit is different)
	ld		r18, X+				;get first data byte

;0.125us
;0.0625us	6.4 / 13.6 	3.2/6.8 3/7		6 14
;			12.8 / 7.2 	6.4/3.6	7/3		13 7

loop1:
	st    Y, r20        ; 2   +0 start of a bit pulse
	lsl		r18					  ; 1   +2 next bit into C, MSB first
	brcs	L1					  ; 1/2 +3 branch if 1
	st    Y, r21       	; 2   +5 end hi for '0' bit (3 clocks hi)
	bst		r18, 7			  ; 1   +7 save last bit of data for fast branching
	subi	r19, 1			  ; 1   +8 how many more bits for this byte?
	breq	bit8				  ; 1/2 +9 last bit, do differently
	rjmp	loop1				  ; 2   +10 10 total for 0 bit
L1:
	bst		r18, 7			  ; 1   +5 save last bit of data for fast branching
	subi	r19, 1			  ; 1   +6 how many more bits for this byte
	st    Y, r21			  ; 1   +7 end hi for '1' bit (7 clocks hi)
	brne	loop1				  ; 2/1 +10 10 total for 1 bit (fall thru if last bit)
bit8:
	ldi		r19, 7			  ; 1   +11 bit count for next byte
	st    Y, r20	  	  ; 1	  +0 start of a bit pulse
	brts	L2					  ; 1/2 +2 branch if last bit is a 1
	st		Y, r21		    ; 2   +3 end hi for '0' bit (3 clocks hi)
	ld		r18, X+			  ; 2   +5 fetch next byte
	sbiw	r24, 1			  ; 2   +7 dec byte counter
	brne	loop1				  ; 2   +9 loop back or return
	out		SREG, r22		  ; restore global int flag
	rjmp end
L2:
	ld		r18, X+			  ; 2   +3 fetch next byte
	sbiw	r24, 1			  ; 2   +5 dec byte counter
	st		Y, r21				; 2   +7
	brne	loop1				  ; 2   +9 loop back or return
	out		SREG, r22		  ; restore global int flag
end:
	ret


ws2812b.S

#include "system.h"
#include "gpio.h"
#include "ws2812b.h"

uint8_t buf[] = {0, 255, 0, 0, 0, 255, 0, 255, 0, 0, 0, 255};
uint8_t buf2[] = {0, 0, 255, 0, 255, 0, 0, 0, 255, 0, 255, 0};

#define DATAPIN PinB5

void setup() {
  pin_mode(DATAPIN, Output);
}

void loop() {
  if (system_ms() % 250 < 125)
    ws2812b_write(DATAPIN, &buf, 12);
  else
    ws2812b_write(DATAPIN, &buf2, 12);
}