/*

 * Master Firmware: SD Card Data Logger

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include "../config.h"

#include <util/delay.h>

#include <string.h>

#include <stdio.h>

#include <avr/pgmspace.h>

#include <avr/sleep.h>

#include <avr/eeprom.h>

#include <string.h>

#include "sd/fat.h"

#include "sd/fat_config.h"

#include "sd/partition.h"

#include "sd/sd_raw.h"

#include "sd/sd_raw_config.h"

#include "logger.h"

#include "led.h"

struct partition_struct* partition;

struct fat_fs_struct* fs;

struct fat_dir_entry_struct directory;

struct fat_dir_struct* dd;

struct fat_file_struct* fd;

void logger_setup()

{

	if(!sd_raw_init())

	{

		// Initializing SD card failed!

		serial0_sendString("SD> Error initializing.\r\n");

		led_errorcode(ERROR_SD_INIT);

		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)

	{

		serial0_sendString("SD> Error opening partition.\r\n");

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

		led_errorcode(ERROR_SD_PARTITION);

		return;

	}

	// Open FAT filesystem

	fs = fat_open(partition);

	if(!fs)

	{

		// opening filesystem failed

		led_errorcode(ERROR_SD_PARTITION);

		return;

	}

	// Open directory

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

	dd = fat_open_dir(fs, &directory);

	if(!dd)

	{

		// opening root directory failed

		_delay_ms(10);

		led_errorcode(ERROR_SD_FILE);

		return;

	}

	// Create new log file

	uint8_t logid = eeprom_read_byte(LOGGER_ID_EEPROM_ADDR);

	char filename[48];

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

	sprintf(filename, "data%d.csv",++logid);

	// TODO: Catch errors here

		led_errorcode(ERROR_SD_FILE);

	}		

	eeprom_update_byte(LOGGER_ID_EEPROM_ADDR, logid);

	// Search for file in current directory and open it

	fd = open_file_in_dir(fs, dd, filename);

	if(!fd)

	{

		led_errorcode(ERROR_SD_FILE);

		_delay_ms(10);

		return;

	}

	// Seek to beginning of file

	// TODO: Is this needed?

	int32_t offset = 0; 

	if(!fat_seek_file(fd, &offset, FAT_SEEK_SET))

	{

		// Error seeking to file

		led_errorcode(ERROR_SD_FILE);

		_delay_ms(10);

		fat_close_file(fd);

		return;

	}

	// Write header information

	logger_log(LOGGER_HEADERTEXT);

	logger_log("\n-- BEGIN DATA --\n");

}	

void logger_log(char *buffer) 

{

	uint8_t len = strlen(buffer);

	if(fat_write_file(fd, (uint8_t*) buffer, len) != len)

	{

		// Error writing to file

		return;

	}

}

void logger_closeLog() 

{

	fat_close_file(fd);

	fat_close_dir(dd);

	fat_close(fs);

	partition_close(partition);

}

// INTERNAL FUNCTIONS

// Opens a file so it can be read/written

struct fat_file_struct* open_file_in_dir(struct fat_fs_struct* fs, struct fat_dir_struct* dd, const char* name)

{

	struct fat_dir_entry_struct file_entry;

	if(!find_file_in_dir(fs, dd, name, &file_entry))

	return 0;

	return fat_open_file(fs, &file_entry);

}

// Searches for file in directory listing

uint8_t find_file_in_dir(struct fat_fs_struct* fs, struct fat_dir_struct* dd, const char* name, struct fat_dir_entry_struct* dir_entry)

{

	while(fat_read_dir(dd, dir_entry))

	{

		if(strcmp(dir_entry->long_name, name) == 0)

		{

			fat_reset_dir(dd);

			return 1;

		}

	}

	return 0;

}

/*

 * Master Firmware

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include "config.h"

#include <avr/io.h>

#include <util/delay.h>

#include <avr/wdt.h>

#include <avr/interrupt.h>

#include <stdio.h>

#include <stdbool.h>

#include "lib/serial.h"

#include "lib/aprs.h"

#include "lib/afsk.h"

#include "lib/led.h"

#include "lib/logger.h"

#include "lib/watchdog.h"

#include "lib/trackuinoGPS/gpsMKa.h"

#include "lib/i2c.h"

#include "lib/boardtemp.h"

#include "lib/looptime.h"

#include "lib/slavesensors.h"

#include "lib/serparser.h"

#include "lib/sensordata.h"

int main(void)

{

    _delay_ms(1500); // warmup

	// Initialize libraries

	time_setup();

	watchdog_setup(); // enables interrupts

	led_setup();	

	serial0_setup();

	serial1_setup();

	i2c_init();

	sensordata_setup(); // must happen before sensors/logger/afsk

	slavesensors_setup();

	logger_setup();

	afsk_setup();

	//\f

	serial0_sendString("\r\n---------------------------------\r\n");

	serial0_sendString("HAB Controller 1.0 - Initialized!\r\n");

	serial0_sendString("---------------------------------\r\n");

	serial0_sendString("\r\nHello.\r\n\r\n");

	slavesensors_network_scan();

	led_on(LED_POWER);

	led_off(LED_SIDEBOARD);

	// Buffer for string operations

	char logbuf[128];

	char debugBuf[128];

	// Software timers	

	uint32_t lastAprsBroadcast = 0;

	uint32_t lastLog = 0;

	uint32_t lastLedCycle = 0;

	// Result of last parser run

	int parseResult = PARSERESULT_NODATA;

	// Write CSV header to SD card

	uint8_t ctr = 0;

	void spin() {

		if(ctr == 0) {

			led_on(LED_ACT0);

			led_off(LED_ACT1);

			led_off(LED_ACT2);

			led_off(LED_ACT3);

		}			

		else if (ctr == 1) {

			led_on(LED_ACT1);

			led_off(LED_ACT0);

			led_off(LED_ACT2);

			led_off(LED_ACT3);

		}			

		else if (ctr == 2) {

			led_on(LED_ACT2);

			led_off(LED_ACT1);

			led_off(LED_ACT0);

			led_off(LED_ACT3);

		}			

		else if (ctr == 3) {

			led_on(LED_ACT3);

			led_off(LED_ACT1);

			led_off(LED_ACT2);

			led_off(LED_ACT0);

		}			

		ctr = (ctr + 1) % 4;

	}

	serial1_ioff();

	while(1)

    {

		// Periodic: LED execution indicator

		if(time_millis() - lastLedCycle > LEDCYCLE_RATE) {

			spin();

			if(!afsk_busy())

				serial1_ion();

			lastLedCycle = time_millis();	

		}

		// Periodic: Logging

		if(time_millis() - lastLog > LOGGER_RATE) 

		{

			led_on(LED_CYCLE);

			// Print out GPS debug

			snprintf(debugBuf, 128, "GPS> time: %s lat: %s lon: %s speed: %s hdop: %s course: %s\r\n",

			get_timestamp(),get_latitude(),get_longitude(),get_speedKnots(),get_hdop(), get_course());

			//serial0_sendString(debugBuf);

			sensors_readBoardTemp(); // i2c read, 400k

			snprintf(logbuf, 128, "%lu,%d,%uF,%s,%s,%s,%s,%s\r\n", time_millis(), sensors_getBoardTemp(),get_timestamp(),get_latitude(),get_longitude(),get_speedKnots(),get_hdop(), get_course());

			logger_log(logbuf);

			// Print out logger debug

			//serial0_sendString("LOG> ");

			//serial0_sendString(logbuf);

			led_off(LED_CYCLE);

			lastLog = time_millis();

		}		

		// Periodic: APRS transmission

		if(time_millis() - lastAprsBroadcast > APRS_TRANSMIT_PERIOD) 

		{

			while(afsk_busy());

			serial1_ioff();

			aprs_send(); // non-blocking

			//serial0_sendString("Initiating APRS transmission...\r\n");

			// Start getting values for next transmission

			if(slavesensors_isrequesting())

			{

				// TODO: something is terribly wrong

			}

			else 

			{				

				slavesensors_startprocess();

			}

			lastAprsBroadcast = time_millis();

		}			

		parseResult = serparser_parse();

		slavesensors_process(parseResult);

		parse_gps_transmission();

		wdt_reset();

    }

}