#define F_CPU 8000000L
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/io.h>
#include <stdint.h>
#include <avr/wdt.h>

//for attiny2313

/*

FUSE SETTINGS:

lfuse=0xe2 (default)
hfuse=0xdf (default)
efuse=0xff (default)

I/O PORTS

PA2: reset
PA1: (o) x
PA0: (o) x

PB7: (i) (sck)
PB6: (o) x (miso)
PB5: (o) x (mosi)
PB4: (o) x
PB3: (o) x
PB2: (o) x
PB1: (o) x
PB0: (o) x

PD6: (o) x
PD5: (o) x
PD4: (o) x
PD3: (o) x
PD2: (i) input (INT0)
PD1: (o) x
PD0: (o) x

MISC

*/

#define A_ 0
#define B_ 1
#define C_ 2
#define D_ 3
#define E_ 4
#define F_ 5
#define G_ 6

#define TIMER0_OVERFLOW (TIFR & (1<<TOV0))

//signals in Stanley NKR-261 display's order

#define E1_PORT PORTD
#define E1_DDR  DDRD
#define E1_PIN  6
#define D1_PORT PORTB
#define D1_DDR  DDRB
#define D1_PIN  2
#define C1_PORT PORTB
#define C1_DDR  DDRB
#define C1_PIN  1
#define DOT_PORT PORTB
#define DOT_DDR  DDRB
#define DOT_PIN  0
#define E2_PORT PORTD
#define E2_DDR  DDRD
#define E2_PIN  5
#define D2_PORT PORTD
#define D2_DDR  DDRD
#define D2_PIN  4
#define G2_PORT PORTD
#define G2_DDR  DDRD
#define G2_PIN  3
#define C2_PORT PORTA
#define C2_DDR  DDRA
#define C2_PIN  0
#define DOT2_PORT (-1)
#define DOT2_DDR  (-1)
#define DOT2_PIN  0

#define B2_PORT PORTA
#define B2_DDR  DDRA
#define B2_PIN  1
#define A2_PORT PORTD
#define A2_DDR  DDRD
#define A2_PIN  1
#define F2_PORT PORTD
#define F2_DDR  DDRD
#define F2_PIN  0
//cathode 2
//cathode 1
#define B1_PORT PORTB
#define B1_DDR  DDRB
#define B1_PIN  3
#define A1_PORT PORTB
#define A1_DDR  DDRB
#define A1_PIN  4
#define G1_PORT PORTB
#define G1_DDR  DDRB
#define G1_PIN  5
#define F1_PORT PORTB
#define F1_DDR  DDRB
#define F1_PIN  6

#define TEST 0
#define DEBUG 0

//bits 0-6 = a-g, bit 7 (MSB) = nothing
volatile uint8_t bits[2]={0,0};
volatile uint8_t dot = 0;
volatile uint8_t update_min_interval_counted = 1;

volatile uint16_t update_max_interval_counter = 0;

void setdigitvalue(uint8_t n, uint8_t v);
void cleardigit1(void);
void cleardigit2(void);
void cleardot(void);
void setdigit1(void);
void setdigit2(void);
void setdot(void);
void setnumber(uint8_t num);
uint8_t calc_rpm100_from_time(uint16_t t);

uint8_t demo[] =
{
(1<<0), (1<<3),
(1<<3), (1<<0),
(1<<4), (1<<1),
(1<<5), (1<<2),
};

uint8_t mcusr_mirror __attribute__((section (".noinit")));

void get_mcusr(void) \
__attribute__((naked)) \
__attribute__((section(".init3")));
void get_mcusr(void)
{
	mcusr_mirror = MCUSR;
	MCUSR = 0;
	wdt_disable();
}

int main(void)
{
	
	// I/O ports

	DDRA = 0x00;
	PORTA = 0x00;
	DDRB = 0x00;
	PORTB = 0x00;
	DDRD = 0x00;
	PORTD = 0x00;

	//timer0 
	
	//set clock divider to 64 (1MHz/64=15625.0Hz=0.064ms/tick, 0.064*256=16.38)
	//TCCR0B |= (1<<CS01) | (1<<CS00);
	//set some compare value
	//OCR0A = 52;//(0.00333/(1.0/(1e6/64)));
	//OCR0A = 16;//(0.001/(1.0/(1e6/64)));
	
	//set clock divider to 256 (1MHz/256=3906Hz=0.256ms/tick, 0.256*256=65)
	TCCR0B |= (1<<CS02);
	//set some compare value
	OCR0A = 31;//(0.001/(1.0/(8e6/256)));

	//timer1
	
	//       clk/64
	//TCCR1B = (1<<CS11) | (1<<CS10);
	//OCR1A = 18750; //50rpm
	//OCR1A = 9375; //100rpm
	//       clk/256
	TCCR1B = (1<<CS12);
	OCR1A = 18750; //100rpm
	//OCR1A = 4687; //100rpm

	//external interrupts

	//      INT0 fall
	MCUCR = (1<<ISC01);

	//interrupts
	
	//       tim0 compA
	TIMSK |= (1<<OCIE0A);

	sei();

	//main loop
	
	/*setdigitvalue(0, 5);
	setdigitvalue(1, 5);
	dot = 0;*/
	
	//if a watchdog timer reset occurred
	if(mcusr_mirror & (1<<WDRF) && DEBUG){
		bits[0] = (1<<6);
		setdigitvalue(1, 1);
		_delay_ms(1000);
	}
	//if a brown-out reset occurred
	else if(mcusr_mirror & (1<<BORF) && DEBUG){
		bits[0] = (1<<6);
		setdigitvalue(1, 2);
		_delay_ms(1000);
	}
	//if an external reset occurred
	else if(mcusr_mirror & (1<<EXTRF) && DEBUG){
		bits[0] = (1<<6);
		setdigitvalue(1, 3);
		_delay_ms(1000);
	}
	else{
		uint8_t i = 0;
		uint8_t k = 0;
		for(k=0; k<2; k++){
			for(i=0; i<sizeof(demo)/2; i++){
				bits[0] = demo[i*2];
				bits[1] = demo[i*2+1];
				_delay_ms(50);
			}
		}
		
		setdigitvalue(0, 5);
		setdigitvalue(1, 5);
		
		_delay_ms(500);

		bits[0] = 0;
		bits[1] = 0;

		_delay_ms(200);
	}

	// watchdog timer

	wdt_enable(WDTO_2S);
	
	// more interrupts

	if(!TEST){
		//      tim1 compA
		TIMSK |= (1<<OCIE1A);
		//      int0 en.
		GIMSK |= (1<<INT0);
	}

	uint16_t j = 18750;
	for(;;){
		if(TEST){
			setnumber(calc_rpm100_from_time(j));
			if(j>64) j -= j>>6;
			else j=18750;
			_delay_ms(20);
		}
		/*if(PIND & (1<<2)) setnumber(1);
		else setnumber(0);*/
		/*setnumber(i);
		if(i<139) i++;
		else i=0;
		_delay_ms(100);*/
	}

	return 0;
}

uint8_t digit_to_value[10] =
{
	(1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5),          //0
	         (1<<1) | (1<<2),                                     //1
	(1<<0) | (1<<1) |          (1<<3) | (1<<4) |          (1<<6), //2
	(1<<0) | (1<<1) | (1<<2) | (1<<3) |                   (1<<6), //3
	         (1<<1) | (1<<2) |                   (1<<5) | (1<<6), //4
	(1<<0) |          (1<<2) | (1<<3) |          (1<<5) | (1<<6), //5
	(1<<0) |          (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6), //6
	(1<<0) | (1<<1) | (1<<2),                                     //7
	(1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6), //8
	(1<<0) | (1<<1) | (1<<2) | (1<<3) |          (1<<5) | (1<<6), //9
};


inline void setdigitvalue(uint8_t n, uint8_t v)
{
	bits[n] = digit_to_value[v];
}

void cleardigit1(void)
{
	A1_DDR &= ~(1<<A1_PIN);
	A1_PORT &= ~(1<<A1_PIN);
	B1_DDR &= ~(1<<B1_PIN);
	B1_PORT &= ~(1<<B1_PIN);
	C1_DDR &= ~(1<<C1_PIN);
	C1_PORT &= ~(1<<C1_PIN);
	D1_DDR &= ~(1<<D1_PIN);
	D1_PORT &= ~(1<<D1_PIN);
	E1_DDR &= ~(1<<E1_PIN);
	E1_PORT &= ~(1<<E1_PIN);
	F1_DDR &= ~(1<<F1_PIN);
	F1_PORT &= ~(1<<F1_PIN);
	G1_DDR &= ~(1<<G1_PIN);
	G1_PORT &= ~(1<<G1_PIN);
}

void cleardigit2(void)
{
	A2_DDR &= ~(1<<A2_PIN);
	A2_PORT &= ~(1<<A2_PIN);
	B2_DDR &= ~(1<<B2_PIN);
	B2_PORT &= ~(1<<B2_PIN);
	C2_DDR &= ~(1<<C2_PIN);
	C2_PORT &= ~(1<<C2_PIN);
	D2_DDR &= ~(1<<D2_PIN);
	D2_PORT &= ~(1<<D2_PIN);
	E2_DDR &= ~(1<<E2_PIN);
	E2_PORT &= ~(1<<E2_PIN);
	F2_DDR &= ~(1<<F2_PIN);
	F2_PORT &= ~(1<<F2_PIN);
	G2_DDR &= ~(1<<G2_PIN);
	G2_PORT &= ~(1<<G2_PIN);
}

void cleardot(void)
{
	DOT_DDR &= ~(1<<DOT_PIN);
	DOT_PORT &= ~(1<<DOT_PIN);
}

void setdigit1(void)
{
	if(bits[0] & (1<<A_)){ A1_PORT |= (1<<A1_PIN); A1_DDR |= (1<<A1_PIN); }
	if(bits[0] & (1<<B_)){ B1_PORT |= (1<<B1_PIN); B1_DDR |= (1<<B1_PIN); }
	if(bits[0] & (1<<C_)){ C1_PORT |= (1<<C1_PIN); C1_DDR |= (1<<C1_PIN); }
	if(bits[0] & (1<<D_)){ D1_PORT |= (1<<D1_PIN); D1_DDR |= (1<<D1_PIN); }
	if(bits[0] & (1<<E_)){ E1_PORT |= (1<<E1_PIN); E1_DDR |= (1<<E1_PIN); }
	if(bits[0] & (1<<F_)){ F1_PORT |= (1<<F1_PIN); F1_DDR |= (1<<F1_PIN); }
	if(bits[0] & (1<<G_)){ G1_PORT |= (1<<G1_PIN); G1_DDR |= (1<<G1_PIN); }
}

void setdigit2(void)
{
	if(bits[1] & (1<<A_)){ A2_PORT |= (1<<A2_PIN); A2_DDR |= (1<<A2_PIN); }
	if(bits[1] & (1<<B_)){ B2_PORT |= (1<<B2_PIN); B2_DDR |= (1<<B2_PIN); }
	if(bits[1] & (1<<C_)){ C2_PORT |= (1<<C2_PIN); C2_DDR |= (1<<C2_PIN); }
	if(bits[1] & (1<<D_)){ D2_PORT |= (1<<D2_PIN); D2_DDR |= (1<<D2_PIN); }
	if(bits[1] & (1<<E_)){ E2_PORT |= (1<<E2_PIN); E2_DDR |= (1<<E2_PIN); }
	if(bits[1] & (1<<F_)){ F2_PORT |= (1<<F2_PIN); F2_DDR |= (1<<F2_PIN); }
	if(bits[1] & (1<<G_)){ G2_PORT |= (1<<G2_PIN); G2_DDR |= (1<<G2_PIN); }
}

void setdot(void)
{
	if(dot){ DOT_PORT |= (1<<DOT_PIN); DOT_DDR |= (1<<DOT_PIN); }
}

uint8_t oldnum = 0;
uint8_t num_rising = 0;

#define HYSTERESIS 1

void setnumber(uint8_t num)
{
	if(update_max_interval_counter > 0){
		if(!update_min_interval_counted) return;
		update_min_interval_counted = 0;
		if(num_rising && num >= oldnum - HYSTERESIS && num < oldnum && num != 0) return;
		if(!num_rising && num <= oldnum + HYSTERESIS && num > oldnum) return;
	}
	update_max_interval_counter = 2000;
	num_rising = (num >= oldnum);
	uint8_t t;
	if(num>=100){
		t = num / 100;
		setdigitvalue(0, t);
		num -= t*100;
		setdigitvalue(1, num/10);
		dot = 0;
	}
	else{
		t = num / 10;
		setdigitvalue(0, t);
		num -= t*10;
		setdigitvalue(1, num);
		dot = 1;
	}
	oldnum = num;
}

ISR(TIMER0_COMPA_vect, ISR_NOBLOCK)
{
	static uint8_t draw_counter = 0;
	static uint8_t counter2 = 0;
	TCNT0 = 0;
	if(draw_counter==0){
		cleardot();
		setdigit1();
		draw_counter = 1;
	}
	else if(draw_counter==1){
		cleardigit1();
		setdigit2();
		draw_counter = 2;
	}
	else if(draw_counter==2){
		cleardigit2();
		setdot();
		draw_counter = 0;
	}
	if(counter2 >= 100){
		counter2 = 0;
		update_min_interval_counted = 1;
	}
	else counter2++;

	if(update_max_interval_counter > 0){
		update_max_interval_counter--;
	}
}

#define PULSE_MIN_TIME 37

uint8_t calc_rpm100_from_time(uint16_t t)
{
	if(t <= PULSE_MIN_TIME) return 255;
	uint16_t r = 37500 / t;
	if(r > 400){
		return (r+20)/4;
	}
	else{
		return (r+2)/4;
	}
}

#define AVGBITS 2
#define AVGLEN (1<<AVGBITS)

uint16_t avg_added = 0;
uint8_t avg_values[AVGLEN] = {0,0,0,0};
uint8_t avg_last = 0;

void setnumber_avg(uint8_t num)
{
	avg_added -= avg_values[avg_last];
	avg_added += num;
	avg_values[avg_last] = num;
	if(avg_last < AVGLEN - 1) avg_last++;
	else avg_last = 0;
	setnumber(avg_added >> AVGBITS);
}

ISR(TIMER1_COMPA_vect)
{
	wdt_reset();
	setnumber_avg(0);
	TCNT1 = 0;
	//clear flag so no new interrupt will be run instantly (from false signals)
	EIFR |= (1<<INTF0);
}

ISR(INT0_vect)
{
	//just divide it by two to allow showing 255 after going over it up to 2x
	if(TCNT1 > PULSE_MIN_TIME/2){
		wdt_reset();
		setnumber_avg(calc_rpm100_from_time(TCNT1));
		TCNT1 = 0;
	}
	//clear flag so no new interrupt will be run instantly (from false signals)
	EIFR |= (1<<INTF0);
}