/*

 * Master Firmware: NMEA Parser

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include <stdbool.h>

#include <string.h>

#include <stdio.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include "gps.h"

#include "serial.h"

#include "../config.h"

#include "led.h"

// Circular buffer for incoming data

uint8_t nmeaBuffer[NMEABUFFER_SIZE];

// Location of parser in the buffer

uint8_t nmeaBufferParsePosition = 0;

// Location of receive byte interrupt in the buffer

volatile uint16_t nmeaBufferDataPosition = 0;

// holds the byte ALREADY PARSED. includes starting character

int bytesReceived = 0;

//data (and checksum) of most recent transmission

char data[16];

//used to skip over bytes during parse

int skipBytes = 0;

//used to index data arrays during data collection

int numBytes = 0;

//variables to store data from transmission

//least significant digit is stored at location 0 of arrays

char tramsmissionType[7];

char timestamp[12];	//hhmmss.ss

char* get_timestamp() 

{

	return timestamp;

}

char latitude[14];	//lllll.lla

char latitudeTmp[8];

char* get_latitudeTrimmed() 

{

	strncpy(latitudeTmp, &latitude[0], 7);

	latitudeTmp[7] = 0x00;

	return latitudeTmp;

}

char* get_latitudeLSBs()

{

	strncpy(latitudeTmp, &latitude[7], 3);

	latitudeTmp[3] = 0x00;

	return latitudeTmp;

}

char longitude[14];	//yyyyy.yyb

/*

 * Master Firmware: Status and Error LED Handler

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#ifndef LED_H_

#define LED_H_

#include <avr/io.h>

enum leds {

	LED_ACT0 = 0,

	LED_ACT1,

	LED_ACT2,

	LED_ACT3,

	LED_POWER,

	LED_STATUS,

	LED_ERROR,

	LED_SIDEBOARD,

	LED_ACTIVITY,

	LED_CYCLE,

	LED_HEAT,

	LED_BUZZ,

};

// Match order of leds enum

static led_t ledList[] = {

	{&DDRA, &PORTA, PA1}, // ACT0

	{&DDRA, &PORTA, PA2}, // ACT1

	{&DDRA, &PORTA, PA3}, // ACT2

	{&DDRA, &PORTA, PA4}, // ACT3

	{&DDRB, &PORTB, PB4}, // POWER

	{&DDRB, &PORTB, PB3}, // STATUS

	{&DDRB, &PORTB, PB2}, // ERROR

	{&DDRD, &PORTD, PD6}, // SIDEBOARD

	{&DDRD, &PORTD, PD5}, // ACTIVITY

	{&DDRD, &PORTD, PD4}, // CYCLE

	{&DDRA, &PORTA, PA6}, // HEAT

	{&DDRA, &PORTA, PA7}, // BUZZER

};

#define NUM_LEDS 12

void led_setup();

void led_on(uint8_t led);

void led_off(uint8_t led);

void led_toggle(uint8_t led);

void led_errorcode(uint8_t code);

void led_spin();

void led_alert();

#endif /* LED_H_ */

void logger_setup()

{

	if(!sd_raw_init())

	{

		error_log(ERROR_SD_INIT, true);

		return;

	}

	// TODO: Check SD card switch to see if inserted.

	// this was included in the library, but is commented out right now

	// Open first partition

	partition = partition_open(sd_raw_read, sd_raw_read_interval, sd_raw_write, sd_raw_write_interval, 0);

	// Check that partition was created correctly

	if(!partition)

	{

		// Error opening partition. MBR might be screwed up.

		error_log(ERROR_SD_PARTITION, true);

		return;

	}

	// Open FAT filesystem

	fs = fat_open(partition);

	if(!fs)

	{

		// opening filesystem failed

		error_log(ERROR_SD_PARTITION, true);

		return;

	}

	// Open root directory

	struct fat_dir_entry_struct rootDirEntry;

	fat_get_dir_entry_of_path(fs, "/", &rootDirEntry);

	dd = fat_open_dir(fs, &rootDirEntry);

	if(!dd)

	{

		// opening root directory failed

		_delay_ms(10);

		error_log(ERROR_SD_FILE, true);

		return;

	}

	// we pre-increment logid here because it starts at 255, then wraps to 0

	int32_t errorOffset = 0;

	char errorFilename[17];

	// Form filename

	snprintf(errorFilename, 17, "run%derror.csv",logid);

	struct fat_dir_entry_struct errorDirEntry;

	if(fat_create_file(dd, errorFilename, &errorDirEntry) == 0)

	{

		serial0_sendString("Error create errorlog\r\n");

		error_log(ERROR_SD_FILE, true);

	}

	// Search for file in current directory and open it

	fd_errorlog = open_file_in_dir(fs, dd, errorFilename);

	if(!fd_errorlog)

	{

		serial0_sendString("Error open errorlog!\r\n");

		error_log(ERROR_SD_FILE, true);

		return;

	}

	errorOffset=0;

	if(!fat_seek_file(fd_errorlog, &errorOffset, FAT_SEEK_SET))

	{

		// Error seeking to file

		serial0_sendString("Error seek errorlog!\r\n");

		error_log(ERROR_SD_FILE, true);

		fat_close_file(fd_errorlog);

		return;

	}

	int32_t dataOffset = 0;

	char dataFilename[17];

	// Form filename

	snprintf(dataFilename, 17, "run%ddata.csv",logid);

	struct fat_dir_entry_struct dataDirEntry;

	// Create new data log file

	if(fat_create_file(dd, dataFilename, &dataDirEntry) == 0) 

	{

		serial0_sendString("Error create datalog\r\n");

		error_log(ERROR_SD_FILE, true);

	}

	// Search for file in current directory and open it

	fd_datalog = open_file_in_dir(fs, dd, dataFilename);

	if(!fd_datalog)

	{

            return 0;

        }

        if(sd_raw_rec_byte() & 0x40)

            sd_raw_card_type |= (1 << SD_RAW_SPEC_SDHC);

        sd_raw_rec_byte();

        sd_raw_rec_byte();

        sd_raw_rec_byte();

    }

#endif

    /* set block size to 512 bytes */

    if(sd_raw_send_command(CMD_SET_BLOCKLEN, 512))

    {

        unselect_card();

        return 0;

    }

    /* deaddress card */

    unselect_card();

    /* switch to highest SPI frequency possible */

    SPCR &= ~((1 << SPR1) | (1 << SPR0)); /* Clock Frequency: f_OSC / 4 */

    SPSR |= (1 << SPI2X); /* Doubled Clock Frequency: f_OSC / 2 */

#if !SD_RAW_SAVE_RAM

    /* the first block is likely to be accessed first, so precache it here */

    raw_block_address = (offset_t) -1;

#if SD_RAW_WRITE_BUFFERING

    raw_block_written = 1;

#endif

    if(!sd_raw_read(0, raw_block, sizeof(raw_block))) {

		return 0;

	}		

#endif

    return 1;

}

/**

 * \ingroup sd_raw

 * Checks wether a memory card is located in the slot.

 *

 * \returns 1 if the card is available, 0 if it is not.

 */

uint8_t sd_raw_available()

{

    return get_pin_available() == 0x00;

}

/**

 * \ingroup sd_raw

 * Checks whether the memory card is locked for write access.

 *

 * \returns 1 if the card is locked, 0 if it is not.

 */

uint8_t sd_raw_locked()

{

    return get_pin_locked() == 0x00;

}

/**

 * \ingroup sd_raw

 * Sends a raw byte to the memory card.

 *

 * \param[in] b The byte to sent.

 * \see sd_raw_rec_byte

 */

void sd_raw_send_byte(uint8_t b)

{

    SPDR = b;

    /* wait for byte to be shifted out */

    while(!(SPSR & (1 << SPIF)));

    SPSR &= ~(1 << SPIF);

}

/**

 * \ingroup sd_raw

 * Receives a raw byte from the memory card.

 *

 * \returns The byte which should be read.

 * \see sd_raw_send_byte

 */

uint8_t sd_raw_rec_byte()

{

    /* send dummy data for receiving some */

    SPDR = 0xff;

    while(!(SPSR & (1 << SPIF)));

    SPSR &= ~(1 << SPIF);

    return SPDR;

}

/**

 * \ingroup sd_raw

 * Send a command to the memory card which responses with a R1 response (and possibly others).

 *

 * \param[in] command The command to send.

 * \param[in] arg The argument for command.

 * \returns The command answer.

 */

uint8_t sd_raw_send_command(uint8_t command, uint32_t arg)

{

    uint8_t response;

		{

			led_alert();	

		}

	}

	// If we finished up one slave, go to the next

	else if(currentSlaveSensor >= (numReadingsToExpect-1))

	{

		#ifdef DEBUG_GETSLAVEDATA

		serial0_sendString("Finished up one slave, go to another.\r\n");

		#endif

		currentSlave++;

		currentSlaveSensor = 0;

		requesting = true;

		slavesensors_request();

	}

	// If we haven't finished a slave (or all of them), just get the next sensor of the current slave

	else

	{

		#ifdef DEBUG_GETSLAVEDATA

		serial0_sendString("Give me another sensor value...");

		#endif

		// request data for the current sensor of the current slave

		currentSlaveSensor++;

		requesting = true;

	}

}

// Request data from slave modules

void slavesensors_process(uint8_t parseResult) 

{

	if(!requesting) 

	{

		// we got a command when we didn't request anything. skip it.

		return;

	}

	// TODO: If we time out, WE NEED TO RESET THE PARSER. It could be in a bad state.

	else if(parseResult == PARSERESULT_NODATA) 

	{

		// Wait for data

		if(requesting && time_millis() - beginRequest > TIMEOUT_SLAVEREQUEST) {

			// if we're requesting, we have no data, and we're over the timeout, this is bad!

			// setParserState(STATE_RESET); - meh, can't do this because it freaking increments the cirbufptr

			gotoNextSlaveOrSensor(true);

			snprintf(msg, 128, "Slave %u (%s) timeout",currentSlave,slaveNames[currentSlave]);

			error_log_msg(ERROR_SLAVETIMEOUT, false, msg); // log error, don't blink LED

		}

	}

	// Finished reception of a message (one sensor data value). If not finished, send out command to get the next one

	else if(parseResult == PARSERESULT_PARSEOK)

	{

		#ifdef DEBUG_GETSLAVEDATA

		char debug[50];

		snprintf(debug, 50, "Slave %u sensor %u of total nodes %u\r\n", currentSlave, currentSlaveSensor,nodeCount);

		serial0_sendString(debug);

		#endif

		// We got data, reset retries

		numRetries = 0;

		// We got some data, let's handle it

		// ASCII payload

		uint8_t len = getPayloadLength();

		char* load = getPayload();

		uint8_t type = getPayloadType();

		int32_t parsedVal = strtol(load, NULL, 10);//atoi(load);

		// Special case for slave telling us how many things we're about to get		

		if(type + 0x30 == '@')

		{

			#ifdef DEBUG_GETSLAVEDATA

			serial0_sendString("Got an awesome count!\r\n");

			serial0_sendChar(parsedVal + 0x30);

			serial0_sendString("\r\n");

			#endif

			numReadingsToExpect = parsedVal;

			currentSlaveSensor = 0;

			requesting = true;

		}

		else 

		{

			// Store data in structure

			sensordata_set(currentSlave,type,parsedVal);

			#ifdef DEBUG_GETSLAVEDATA

			serial0_sendString("Stored some sexy data!\r\n");

			#endif 

				led_on(LED_SIDEBOARD);

			}

			else 

			{

				led_off(LED_SIDEBOARD);

			}

			sensors_readBoardTemp();

			// Write CSV header and log data values

			sensordata_logvalues();			

			led_off(LED_CYCLE);

			lastLog = time_millis();

		}		

		// Periodic: Data Request

		if(time_millis() - lastDataReq > DATAREQUEST_RATE)  

		{

			// Start getting values for next transmission

			if(slavesensors_isrequesting())

			{

				// TODO: something is terribly wrong. Timeout?

			}

			else

			{

				slavesensors_startprocess();

			}

			lastDataReq = time_millis();

		}

		// Periodic: APRS transmission

		if(time_millis() - lastAprsBroadcast > APRS_TRANSMIT_PERIOD) 

		{

			// Ensure we aren't already transmitting

			while(afsk_busy());

			// Turn off interrupts and transmit APRS sentence

			serial1_ioff();

			aprs_send(); // non-blocking

			lastAprsBroadcast = time_millis();

		}			

		// Parse any serial data in the XBee software buffer

		parseResult = serparser_parse();

		slavesensors_process(parseResult);

		// Parse any NMEA messages in the GPS software buffer

		parse_gps_transmission();

		wdt_reset();

    }

}