#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdbool.h>
#include "timer.h"

static volatile uint64_t _microseconds = 0;
static volatile uint16_t _beep_counter;
static uint8_t _beep_port;
static uint8_t _beep_pin;

volatile uint8_t * reg;
uint8_t bit = 0;

ISR(TIMER0_OVF_vect) {
	_microseconds += 2048;
	if (_beep_counter > 0) {
		PORTB ^= _BV(PORTB2);
		//pin_toggle(_beep_port, _beep_pin);
		_beep_counter--;
	}
}

uint64_t timer_us() {
	return _microseconds;
}

uint32_t timer_ms() {
	return timer_us() / 1000;
}

void timer_enable() {
	TCCR0A |= _BV(WGM00) | _BV(WGM01);
	TCCR0B |= _BV(CS00) | _BV(CS01); //clk/64
#if defined (__AVR_ATtiny85__)
	TIMSK |= _BV(TOIE0);
#else
	TIMSK0 |= _BV(TOIE0);
#endif
	sei();
}

void timer_disable() {
	TCCR0A = 0;
	TCCR0B = 0;
#if defined (__AVR_ATtiny85__)
	TIMSK &= ~_BV(TOIE0);
#else
	TIMSK0 &= ~_BV(TOIE0);
#endif
}

void enable_pwm_a(){
	TCCR0A |= _BV(COM0A1);
}
void enable_pwm_b() {
	TCCR0A |= _BV(COM0B1);
}
void output_pwm_a(uint8_t value) {
	OCR0A = value;
}
void output_pwm_b(uint8_t value) {
	OCR0B = value;
}
void disable_pwm_a() {
	TCCR0A &= ~(_BV(COM0A0) | _BV(COM0A1));
}
void disable_pwm_b() {
	TCCR0A &= ~(_BV(COM0B0) | _BV(COM0B1));
}

void beep(uint16_t duration) {
	_beep_counter = duration;
}

timer.c

#include <stdint.h>

void timer_enable();
void timer_disable();
uint64_t timer_us();
uint32_t timer_ms();

void enable_pwm_a();
void enable_pwm_b();
void output_pwm_a(uint8_t value);
void output_pwm_b(uint8_t value);
void disable_pwm_a();
void disable_pwm_b();

void beep(uint16_t duration);

timer.h

#include <avr/io.h>
#include "timer.h"
#include "light.h"
#include "button.h"
#include "encoder.h"
#include "test.h"
#include "ws2812b.h"

button_t button;
encoder_t encoder;
GRB8 grb[3];

typedef enum {
	LEVEL,
	HUE,
	SATURATION
} mode_t;

mode_t _mode;
void handle_button_event(button_event_t e) {
	if (e == BUTTON_HOLD) {
		if (_mode == LEVEL) {
			beep(200);
			_mode = SATURATION;
		} else if (_mode == HUE || _mode == SATURATION) {
			_mode = LEVEL;
		}
	} else if (e == BUTTON_RELEASED) {
			beep(10);
		if (_mode == SATURATION) {
			_mode = HUE;
		} else if (_mode == HUE) {
			_mode = LEVEL;
		} else if (_mode == LEVEL) {
			lightFadeToggle(&light);
		}
	} else if (e == BUTTON_RELEASEDHOLD) {
	}
}

void handle_encoder_event(encoder_event_t e) {
	if (e == ENCODER_LEFT) {
		beep(5);
		if (_mode == LEVEL) {
			lightDecreaseLevel(&light);
		} else if (_mode == HUE) {
			lightDecreaseHue(&light);
		} else if (_mode == SATURATION) {
			lightDecreaseSaturation(&light);
		}
	} else if (e == ENCODER_RIGHT) {
		beep(5);
			if (_mode == LEVEL) {
			lightIncreaseLevel(&light);
		} else if (_mode == HUE) {
			lightIncreaseHue(&light);
		} else if (_mode == SATURATION) {
			lightIncreaseSaturation(&light);
		}
	}
}

int main() {
	DDRB |= _BV(1) | _BV(2);
	PORTB |= _BV(5) | _BV(3) | _BV(4);
	
	timer_enable();
	//enable_pwm_a();
	while (1) {
		bool sw = !(PINB & _BV(PB4));
		bool clk = !(PINB & _BV(PB5));
		bool dir = !(PINB & _BV(PB3));
		e = button_debounce(&button, sw);
		if (e)
			handle_button_event(e);
		f = encoder_debounce(&encoder, clk, dir);
		if (f)
			handle_encoder_event(f);
		grb[0] = lightGRB8(&light);
		grb[1] = lightGRB8(&light);
		grb[2] = lightGRB8(&light);
		ws2812b_writegrb(0x11, &grb, 9);

		//if (timer_ms() % 1000 < 500)
		//if (light.level > 0)
		//	PORTB |= _BV(0);
		//else	
		//	PORTB &= ~_BV(0);
		//output_pwm_a(0);
		lightLoop(&light);
	}
}


LightController.c

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdbool.h>
#include <stddef.h>
#include "adc.h"

static adc_conversion_t _adc_queue[ADC_QUEUE_LENGTH + 1];
static volatile uint8_t _adc_queue_head;
static volatile uint8_t _adc_queue_tail;

void adc_set_aref_reference() {
	ADMUX = 0;
}

inline void adc_set_vcc_reference() {
	ADMUX = _BV(REFS0);
}

void adc_set_1v1_reference() {
	ADMUX = _BV(REFS0) | _BV(REFS1);
#if defined (__AVR_ATmega256__)
	ADMUX = _BV(REFS1);
#elif defined (__AVR_ATtiny85__)
	ADMUX = _BV(REFS0) | _BV(REFS1);
#endif
}

#if defined (__AVR_ATtiny85__) || defined (__AVR_ATmega2560__)
void adc_set_2v56_reference() {
#if defined (__AVR_ATtiny85__)
	ADMUX &= ~(_BV(REFS0) | _BV(REFS2));
#else
	ADMUX &= ~_BV(REFS0);
#endif
	ADMUX |= _BV(REFS1);
}
#endif

void adc_enable(void)	{
	adc_set_vcc_reference();
	ADCSRA |= _BV(ADEN) | _BV(ADPS2) | _BV(ADPS1) | _BV(ADPS0); // clk/128
}

void adc_disable(void) {
	ADCSRA = 0;
	ADMUX = 0;
}

void _start_next_conversion() {
	adc_conversion_t * conversion = &_adc_queue[_adc_queue_tail];
	ADMUX = (ADMUX & 0xF0) | conversion->channel;
	ADCSRA |= _BV(ADSC);
}

adc_conversion_t * adc_convert(uint8_t channel) {
	uint8_t next = (_adc_queue_head < ADC_QUEUE_LENGTH ? _adc_queue_head + 1 : 0);
	if (next == _adc_queue_tail)
		return NULL;
	adc_conversion_t * conversion = &_adc_queue[_adc_queue_head];
	conversion->channel = channel;
	bool queue_was_empty = (_adc_queue_head == _adc_queue_tail);
	_adc_queue_head = next;
	if (queue_was_empty) {
		ADCSRA |= _BV(ADIE);
		_start_next_conversion();
	}
	return conversion;
}

ISR(ADC_vect) {
	adc_conversion_t * conversion = &_adc_queue[_adc_queue_tail];
	conversion->value = ADCW;
	conversion->completed = true;
	uint8_t next = (_adc_queue_tail < ADC_QUEUE_LENGTH ? _adc_queue_tail + 1 : 0);
	_adc_queue_tail = next;
	if (_adc_queue_head == _adc_queue_tail)
		ADCSRA &= ~_BV(ADIE);
	else
		_start_next_conversion();
}


adc.c

#ifndef adc_h
#define adc_h

#include <stdint.h>
#include <stdbool.h>

#if !defined(ADC_QUEUE_LENGTH)
	#define ADC_QUEUE_LENGTH 20
#endif

typedef struct {
	uint8_t channel;
	volatile bool completed;
	volatile uint16_t value;
} adc_conversion_t;

void adc_set_aref_reference();
void adc_set_vcc_reference();
void adc_set_1v1_reference();
#if defined (__AVR_ATtiny85__) | defined (__AVR_ATmega2560__)
void adc_set_2v56_reference();
#endif
void adc_enable();
void adc_disable();
adc_conversion_t * adc_convert(uint8_t channel);

#endif


adc.h

#include <avr/io.h>

#define __SFR_OFFSET 0

.global ws2812b_writegrb

ws2812b_writegrb:
	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 <stdint.h>

void ws2812b_writegrb(uint8_t pin, uint8_t * data, uint16_t len);


ws2812b.h

#include "light.h"
#include <math.h>
#include <stdint.h>
#include <stdlib.h> //malloc

#define FADEIN_DURATION 1000
#define FADEOUT_DURATION 800
#define LEVEL_STEPS 20
#define HUE_STEPS 32
#define SATURATION_STEPS 32
#define TEMPERATURE_STEPS 32

void lightIncreaseLevel(light_t *light) {
	if (light->state == LIGHT_OFF)
		light->state = LIGHT_ON;
	light->level += 1.0 / LEVEL_STEPS;
	if (light->level > 1)
		light->level = 1;
}

void lightDecreaseLevel(light_t *light) {
	light->level -= 1.0 / LEVEL_STEPS;
	if (light->level <= 0) {
		light->level = 0;
		light->state = LIGHT_OFF;
	}
}

void lightSet(light_t *light, bool value) {
	if (value)
		lightOn(light);
	else
		lightOff(light);
}

void lightOn(light_t *light) {
	if (light->state != LIGHT_ON) {
		light->state = LIGHT_ON;
		light->level = 1;
	}
}

void lightOff(light_t *light) {
	if (light->state != LIGHT_OFF) {
		light->state = LIGHT_OFF;
		light->level = 0;
	}
}

void lightToggle(light_t *light) {
	if (light->state == LIGHT_OFF || light->state == LIGHT_FADING_OUT)
		lightOn(light);
	else if (light->state == LIGHT_ON || light->state == LIGHT_FADING_IN)
		lightOff(light);
}

void lightFadeIn(light_t *light) {
	if (light->state == LIGHT_OFF || light->state == LIGHT_FADING_OUT) {
		light->state = LIGHT_FADING_IN;
		light->_fadeStart = timer_ms();
		light->_fadeLevel = light->level;
	}
}

void lightFadeOut(light_t *light) {
	if (light->state == LIGHT_ON || light->state == LIGHT_FADING_IN) {
		light->state = LIGHT_FADING_OUT;
		light->_fadeStart = timer_ms();
		light->_fadeLevel = light->level;
	}
}

void lightFadeToggle(light_t *light) {
	if (light->state == LIGHT_OFF || light->state == LIGHT_FADING_OUT)
		lightFadeIn(light);
	else if (light->state == LIGHT_ON || light->state == LIGHT_FADING_IN)
		lightFadeOut(light);
}

void lightLoop(light_t *light) {
	switch (light->state) {
		case LIGHT_FADING_IN:
			light->level += 0.001;
			//light->level = light->_fadeLevel +
			//		(1. - light->_fadeLevel) *
			//		(float)(timer_ms() - light->_fadeStart) / (float)FADEIN_DURATION;
			if (light->level < 0) {
				asm("nop");
			}
			if (light->level > 1) {
				light->level = 1;
				light->state = LIGHT_ON;
			}
			break;
		case LIGHT_FADING_OUT:
			//light->level = light->_fadeLevel - light->_fadeLevel * (double)(timer_ms() - light->_fadeStart) / (float)FADEOUT_DURATION;
			light->level -= 0.001;
			if (light->level < 0) {
				light->level = 0;
				light->state = LIGHT_OFF;
			}
			break;
		case LIGHT_ON:
			break;
		case LIGHT_OFF:
			break;
	}
}

void lightIncreaseHue(light_t *light) {
	light->hue += 1.0 / HUE_STEPS;
	if (light->hue >= 1)
		light->hue -= 1;
}

void lightDecreaseHue(light_t *light) {
	light->hue -= 1.0 / HUE_STEPS;
	if (light->hue < 0)
		light->hue += 1;
}

void lightIncreaseSaturation(light_t *light) {
	light->saturation += 1.0 / SATURATION_STEPS;
	if (light->saturation > 1)
		light->saturation = 1;
}

void lightDecreaseSaturation(light_t *light) {
	light->saturation -= 1.0 / SATURATION_STEPS;
	if (light->saturation < 0)
		light->saturation = 0;
}

void lightIncreaseWhiteTemperature(light_t *light) {
	light->whiteTemperature += 1.0 / TEMPERATURE_STEPS;
	if (light->whiteTemperature >= 1)
		light->whiteTemperature -= 1;
}

void lightDecreaseWhiteTemperature(light_t *light) {
	light->whiteTemperature -= 1.0 / HUE_STEPS;
	if (light->whiteTemperature < 0)
		light->whiteTemperature += 1;
}

RGB hsv2rgb(double h, double s, double v) {
	double r, g, b;
	double p, q, t, fract;
	h = h * 360.;
	(h == 360.) ? (h = 0.) : (h /= 60.);
	fract = h - floor(h);
	p = v * (1. - s);
	q = v * (1. - s * fract);
	t = v * (1. - s * (1. - fract));
	if (0 <= h && h < 1) {
		r = v; g = t; b = p;
	} else if (1 <= h && h < 2) {
		r = q; g = v; b = p;
	} else if (2 <= h && h < 3) {
		r = p; g = v; b = t;
	} else if (3 <= h && h < 4) {
		r = p; g = q; b = v;
	} else if (4 <= h && h < 5) {
		r = t; g = p; b = v;
	} else if (5 <= h && h < 6) {
		r = v; g = p; b = q;
	} else {
		r = 0; g = 0; b = 0;
	}
	return (RGB) {r, g, b};
}

RGB lightRGB(light_t *light) {
	return hsv2rgb(light->hue, light->saturation, light->level);
}

GRB8 lightGRB8(light_t *light) {
	RGB c = lightRGB(light);
	return (GRB8) {255 * c.g, 255 * c.r, 255 * c.b};
}

/*
RGB light_t::rgb() {
	return hsv2rgb(_hue, _saturation, _level);
}


int correct(double value) {
	return int(pow(pow(255, 0.33) * ((float)(value * 100) / (float)100), 1 / 0.33) + 0.5);
}

const uint8_t PROGMEM gamma[] = {
		0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
		0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,
		1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,
		2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  5,  5,  5,
		5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9, 10,
		10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,
		17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
		25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,
		37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,
		51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,
		69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,
		90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,
		115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,
		144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,
		177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,
		215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255
	};*/


//RGB rgb = hsv2rgb(_hue, _saturation, _level);
//uint8_t r = pgm_read_byte(&gamma[(int)(rgb.r * 255.)]);
//uint8_t g = pgm_read_byte(&gamma[(int)(rgb.g * 255.)]);
//uint8_t b = pgm_read_byte(&gamma[(int)(rgb.b * 255.)]);

void ledstrip_init(ledstrip_t *s, uint8_t numpixels) {
	s->numpixels = numpixels;
	s->pixels = malloc(3 * numpixels);
}


light.c

#ifndef light_h
#define light_h
#include <stdint.h>
#include <stdbool.h>

typedef enum {
	LIGHT_OFF = 0,
	LIGHT_FADING_IN,
	LIGHT_ON,
	LIGHT_FADING_OUT
} light_state_t;

typedef struct {
	light_state_t state;
	float level;
	uint32_t  _fadeStart;
	float _fadeLevel;
	float hue;
	float saturation;
	float whiteTemperature;
} light_t;

void lightIncreaseLevel(light_t *light);
void lightDecreaseLevel(light_t *light);
void lightSetLevel(light_t *light, bool value);
void lightOn(light_t *light);
void lightOff(light_t *light);
void lightToggle(light_t *light);
void lightFadeIn(light_t *light);
void lightFadeOut(light_t *light);
void lightFadeToggle(light_t *light);
void lightLoop(light_t *light);

void lightIncreaseHue(light_t *light);
void lightDecreaseHue(light_t *light);
void lightIncreaseSaturation(light_t *light);
void lightDecreaseSaturation(light_t *light);
void lightIncreaseWhiteTemperature(light_t *light);
void lightDecreaseWhiteTemperature(light_t *light);

typedef struct {
	double r; // ∈ [0, 1]
	double g; // ∈ [0, 1]
	double b; // ∈ [0, 1]
} RGB;

typedef struct {
	uint8_t g;
	uint8_t r;
	uint8_t b;
} GRB8;

RGB hsv2rgb(double hue, double saturation, double level);
GRB8 lightGRB8(light_t *light);
RGB lightRGB(light_t *light);

typedef struct {
	GRB8 *pixels;
	uint8_t numpixels;
} ledstrip_t;

void ledstrip_init(ledstrip_t *s, uint8_t numpixels);


#endif


light.h

#ifndef button_h
#define button_h

#include <stdint.h>
#include <stdbool.h>

#define BUTTON_DEBOUNCE_DURATION 20
#define BUTTON_HOLD_DURATION 1000

typedef enum {
	BUTTON_PRESSED = 1,
	BUTTON_RELEASED = 2,
	BUTTON_HOLD = 3,
	BUTTON_RELEASEDHOLD = 4
} button_event_t;

typedef struct {
	bool state;
	unsigned long _stamp;
	bool _holding;
} button_t;

button_event_t button_debounce(button_t *button, bool value);

#endif


button.h

#include "button.h"
#include "timer.h"
#include <stdint.h>

button_event_t button_debounce(button_t *button, bool value) {
	unsigned long now = timer_ms();
	if (!button->state && value && now - button->_stamp > BUTTON_DEBOUNCE_DURATION) {
		button->state = true;
		button->_stamp = now;
		return BUTTON_PRESSED;
	}
	if (button->state && value && !button->_holding && now - button->_stamp > BUTTON_HOLD_DURATION) {
		button->_holding = true;
		return BUTTON_HOLD;
	}
	if (button->state && !value && now - button->_stamp > BUTTON_DEBOUNCE_DURATION) {
		button->state = false;
		button->_stamp = now;
		if (button->_holding) {
			button->_holding = false;
			return BUTTON_RELEASEDHOLD;
		}
		return BUTTON_RELEASED;
	}
	return 0;
}


button.c

diagram.json

button_event_t e;
encoder_event_t f;
light_t light;


test.h

#ifndef switch_h
#define switch_h

#define SWITCH_DEBOUNCE_DURATION 20

#include <stdint.h>
#include <stdbool.h>

typedef enum {
	SWITCH_CLOSED = 1,
	SWITCH_RELEASED = 2
} switch_event_t;

typedef struct {
	bool state;
	uint32_t _stamp;
} switch_t;

switch_event_t switch_debounce(switch_t * sw, bool value);

#endif


switch.h

#include "switch.h"

switch_event_t switch_debounce(switch_t *sw, bool value) {
	uint32_t now = timer_ms();
	if (!sw->state && value && now - sw->_stamp > SWITCH_DEBOUNCE_DURATION) {
		sw->state = true;
		sw->_stamp = now;
		return SWITCH_CLOSED;
	}
	if (sw->state && !value && now - sw->_stamp > SWITCH_DEBOUNCE_DURATION) {
		sw->state = false;
		sw->_stamp = now;
		return SWITCH_RELEASED;
	}
	return 0;
}


switch.c

#ifndef encoder_h
#define encoder_h

#include <stdint.h>
#include <stdbool.h>

#define ENCODER_DEBOUNCE_DURATION 20

typedef enum {
	ENCODER_LEFT = 1,
	ENCODER_RIGHT = 2
} encoder_event_t;

typedef struct {
	bool state;
	unsigned long _stamp;
} encoder_t;

encoder_event_t encoder_debounce(encoder_t *encoder, bool clk, bool dir);

#endif


encoder.h

#include "encoder.h"
#include "timer.h"
#include <stdint.h>

encoder_event_t encoder_debounce(encoder_t *enc, bool clk, bool dir) {
	unsigned long now = timer_ms();
	if (!enc->state && clk) {
		enc->state = true;
		enc->_stamp = now;
		if (dir)
			return ENCODER_LEFT;
		else
			return ENCODER_RIGHT;
	}
	if (enc->state && !clk && now - enc->_stamp > ENCODER_DEBOUNCE_DURATION) {
		enc->state = false;
		enc->_stamp = now;
	}
	return 0;
}
