// GPS clock
//
// This software runs on a ATMEGA162. It receives GPS messages and displays the time and date 
// on 4 7 segment displays. Two buttons are connected. After pressing button A, the date is shown.
// After pressing button B, the hours will be set one hour forward.
//
// This is free software, enjoy!
//
// Count0, feb 2013

#include <avr/io.h>
#include <avr/interrupt.h>

#define COMPARING	0	// Recieving states
#define READING		1
#define DONE		2
#define SHOW_TIME	0	// Showing states
#define SHOW_DAY	1
#define SHOW_MONTH	2
#define SHOW_YEAR	3

volatile char state_recieving;				// Machine state while recieving
volatile char state_showing = SHOW_TIME;	// Machine state while showing

volatile char valueA = 0;	// These contain the actual values shown on the displays
volatile char valueB = 0;
volatile char valueC = 0;
volatile char valueD = 0;

volatile char imageA;	// These contain the bitmaps corresponding with the values
volatile char imageB;
volatile char imageC;
volatile char imageD;

volatile char message[100];			// A string to receive the sentence from the GPS
static char compare[] = "$GPZDA,";  // This is the start of the sentence we want to capture
volatile char messageCount;			// The number of chars read during successfully reading
volatile int index1;				// Indexes for the strings
volatile int index2;

volatile char keyBpressed = 0;	// 0 = not pressed
volatile char udr_data;			// Will contain UDR value
volatile char hourOffset = 1;	// This value will be added to the time the GPS delivers

void toDecimal(int decimal) // Express a value from 0 to 9999 as 4 chars (for debugging)
{
	if (decimal < 10000)
	{
		valueA = decimal / 1000;
		decimal = decimal - valueA * 1000;
		valueB = decimal / 100;
		decimal = decimal - valueB * 100;
		valueC = decimal / 10;
		decimal = decimal - valueC * 10;
		valueD = decimal;
	}
	else
	{
		valueA = 14;
		valueB = 14;
		valueC = 14;
		valueD = 14;
	}
}

ISR(TIMER1_COMPA_vect) // Timer tick, we are now some time after we received the GPS char
{	
	TCCR1B &= ~((1 << CS12));	// Stop timer clock
	char hours;

	if (state_showing == SHOW_TIME)
	{	
		if (keyBpressed)	// Increse the offset if key B was pressed
		{
			hourOffset++;
			if (hourOffset == 24) hourOffset = 0;
		}
		
		valueD = message[3] - 48;	// Set minutes,
		valueC = message[2] - 48;	// 48 is ASCII for number 0
		
		valueA = 0;
		hours = message[1] + ((message[0] -48) * 10) - 48 + hourOffset; // Recalculate to real hours + offset
		
		if (hours > 23) hours = hours -24;	// Express hours as two chars
		while (hours > 9)
		{
		valueA++;
		hours = hours - 10;
		}
		valueB = hours;
		
		message[48]	= 13; // CR, terminate the message for sending
		message[49]	= 10; // LF
		message[50] = 0;  // Null
		index1 = 0;
		
		while(message[index1]) // Output message for debug purposes
		{
			while(!(UCSR0A & (1<<UDRE0))){}	//Wait untill the transmitter is ready
			UDR0 = message[index1];
			index1++;
		}
	}
	
	if (state_showing == SHOW_YEAR)
	{
		valueA = message[17] - 48;
		valueB = message[18] - 48;
		valueC = message[19] - 48;
		valueD = message[20] - 48;
		state_showing = SHOW_TIME;
	}
	
	if (state_showing == SHOW_MONTH)
	{
		valueA = 0x10;
		valueB = 0x10;
		valueC = message[14] - 48;
		valueD = message[15] - 48;
		state_showing = SHOW_YEAR;
	}
	
	if (state_showing == SHOW_DAY)
	{
		valueA = 0x10;
		valueB = 0x10;
		valueC = message[11] - 48;
		valueD = message[12] - 48;
		state_showing = SHOW_MONTH;
	}
			
	index1 = 0;
	index2 = 0;
	state_recieving = COMPARING;

	keyBpressed	= 0;
}

ISR(USART0_RXC_vect) // Serial char received 
{	
	udr_data = UDR0;	// Fetch the received byte
	
	if (state_recieving == READING) // We had the right prefix
	{
		if (messageCount++ < 50)	message[index1++] = udr_data; // Add the char to the message string.
		else
		{
			state_recieving = DONE;	// Stop receiving
			messageCount = 0;
		}
	}
	
	if (state_recieving == COMPARING) // We are checking for the right prefix ($GPRMC,)
	{
		if (udr_data == compare[index2]) // Char match?
			{
				index2++;
				if (udr_data == ',' ) state_recieving = READING; // Last char yes? then start reading the rest
			}				
		else index2 = 0; // We had a wrong char, compare from start again.
	}	
	
	TCNT1 = 0;					// Reset the clock and set it running.
	TCCR1B |= ((1 << CS12));	// Precaler 256.
}

char toImage(char decimal)	// Deliver the bitmap to the corresponding value 
{
	char x = 255;
	if (decimal == 0x00) x = 0b11000000; // 0
	if (decimal == 0x01) x = 0b11111001; // 1
	if (decimal == 0x02) x = 0b10100100; // 2
	if (decimal == 0x03) x = 0b10110000; // 3
	if (decimal == 0x04) x = 0b10011001; // 4
	if (decimal == 0x05) x = 0b10010010; // 5
	if (decimal == 0x06) x = 0b10000010; // 6
	if (decimal == 0x07) x = 0b11111000; // 7
	if (decimal == 0x08) x = 0b10000000; // 8
	if (decimal == 0x09) x = 0b10010000; // 9
	if (decimal == 0x0A) x = 0b10001000; // A
	if (decimal == 0x0B) x = 0b10000011; // B
	if (decimal == 0x0C) x = 0b11000110; // C
	if (decimal == 0x0D) x = 0b10100001; // D
	if (decimal == 0x0E) x = 0b10000110; // E
	if (decimal == 0x0F) x = 0b10001110; // F
	if (decimal == 0x10) x = 0b11111111; // blank
	
	return x;
}

void init_USART()
{
	UBRR0L = 31;		//  14400 baud @ 7.372.800 Hz
	UBRR0H = 0;

	UCSR0B = (1<<RXEN0 | 1<<TXEN0);		// Enable RX and TX
	UCSR0C = (1<<URSEL0)|(3<<UCSZ00);	// 8 data, 1 stop bit
	
	UCSR0B |= (1 << RXCIE0); // Enable receive interrupt
}

void init_timer(void)
{
	// P is Period between ticks:
	// P = OCR * prescaler * (1/clock)
	// So:
	// OCR = P / (precaler * (1/clock))
	// (Clock in hz, P in secs)
	
	TCCR1B |= (1 << WGM12);		// Configure timer 1 for CTC mode
	TCCR1B |= ((1 << CS12));	// Precaler 256
	OCR1A   = 2880;				// Set CTC compare value to 0.1 Hz at 7.372.800 Hz AVR clock
	TIMSK |= (1 << OCIE1A);		// Enable CTC interrupt
}

int main (void)
{
	DDRA = 255;			// Segments for display 1 & 2
	DDRB = 0b00001111;	// Common cathodes for displays 1 through 4
	DDRC = 255;			// Segments for display 1 & 2
	DDRD = 0b00000100;	// Configure port D as input except pin 3, for debugging
	PORTD = 0b11000000; // Configure pin 6 and 7 with pull up resistors active (button A, button B)
	
	index1 = 0;
	index2 = 0;
	
	init_timer();
	init_USART();
	sei();			//  Enable global interrupts
	
	while (1)	// Multiplex the displays and check for key presses while no interrupt is taken care of
	{
		imageA = toImage(valueA);
		imageC = toImage(valueC);
		PORTA = imageA;
		PORTC = imageC;
		PORTB = 0b00000101;	// Light display A and C
		
		imageB = toImage(valueB);
		imageD = toImage(valueD);
		PORTA = imageB;
		PORTC = imageD;
		PORTB = 0b00001010;	// Light display B and D
		
		if (!(PIND & 1 << 6)) state_showing = SHOW_DAY; // Check if Pin is pulled low
		if (!(PIND & 1 << 7)) keyBpressed = 1;
	}
}