#define ERROR_SD_INIT 1

#define ERROR_SD_PARTITION 2

#define ERROR_SD_FILE 3

#define ERROR_XBEETIMEOUT 4

#define ERROR_FATAL 5

#define ERROR_ATFAIL 6

#define ERROR_EXITAT 7

// !!! Please specify detailed messages for these error codes in logger.c

// --------------------------------------------------------------------------

// Slave Sensors config (slavesensors.c)

// --------------------------------------------------------------------------

#define MAX_NUM_SLAVES 5  // Maximum number of nodes in the system

#define MAX_NUM_SENSORS 10 // Maximum number of unique types of sensors in the system

// Node identifier of log destination xbee

#define XBEE_LOGDEST_NAME "HAB-LOGGER"

#define DATAREQUEST_RATE 3000

// --------------------------------------------------------------------------

// Command Parser config (serparser.c)

// --------------------------------------------------------------------------

// Maximum payload size of command

#define MAX_PAYLOAD_LEN 16

// Circular serial buffer size. Must be at least MAX_CMD_LEN + 5

#define BUFFER_SIZE 128 

// Public broadcast address

#define BROADCAST_ADDR 0 

char course[8];		//xxx.x

char* get_course() 

{

	return course;

}

char dayofmonth[9];	//ddmmyy

char* get_dayofmonth() 

{

	return dayofmonth;

}

bool gps_hasfix() 

{

}

char variation[9];	//xxx.xb

int calculatedChecksum;

int receivedChecksum;

// transmission state machine

enum decodeState {

	//shared fields

	INITIALIZE=0,

	GET_TYPE,

	GPS_CHECKSUM,	//XOR of all the bytes between the $ and the * (not including the delimiters themselves), written in hexadecimal

#include <avr/eeprom.h>

#include <string.h>

#include "sdcard/fat.h"

#include "sdcard/fat_config.h"

#include "sdcard/partition.h"

#include "sdcard/sd_raw.h"

#include "sdcard/sd_raw_config.h"

#include "serial.h"

#include "logger.h"

#include "led.h"

#include "looptime.h"

// Label lookup table

// Make sure there are never more labels than there are MAX_NUM_SENSORS!

const char err_0[] PROGMEM = "slave timeout";

const char err_1[] PROGMEM = "initializing SD card failed";

const char err_2[] PROGMEM = "opening SD partition failed";

const char err_3[] PROGMEM = "opening SD file failed";

const char err_4[] PROGMEM = "XBee timeout";

const char err_5[] PROGMEM = "FATAL UNHANDLED ERROR";

const char err_6[] PROGMEM = "enter AT mode failed";

const char err_7[] PROGMEM = "exit AT mode failed";

const char *const errorMessageLookup[] PROGMEM =

{

	err_0,

	err_1,

	err_2,

	err_3,

	err_4,

	err_5,

	err_6,

	err_7,

};

struct partition_struct* partition;

struct fat_fs_struct* fs;

struct fat_dir_struct* dd;

struct fat_file_struct* fd_datalog;

struct fat_file_struct* fd_errorlog;

void logger_setup()

{

	}

	char errorLine[256];

	snprintf(errorLine, 256, "%lu,%u,%s,%s,\r\n", time_millis(), errNo, labelBuffer, infoText);

	error_log_rawwrite(errorLine);

	led_on(LED_ERROR);

	if(flashLED)

	{

		led_errorcode(errNo);

	}

}

void error_log_rawwrite(char *buffer) 

{

	uint8_t len = strlen(buffer);

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

	{

		// Error writing to file

		return;

	}

}

#ifndef LOGGER_H_

#define LOGGER_H_

#include <stdbool.h>

void logger_setup();

uint8_t logger_writeLine(char* dateLine, uint8_t length);

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

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);

void error_log(uint8_t errNo, bool flashLED);

void error_log_msg(uint8_t errNo, bool flashLED, char* infoText);

void error_log_rawwrite(char *buffer);

void logger_log(char *buffer);

void logger_closeLog();

#endif /* LOGGER_H_ */

	else 

	{

		return 0;

	}

}

// Generate APRS comment

// TODO: Can we move this buffer to a local scope of this function?

char commentBuffer[128];

char* slavesensors_getAPRScomment() 

{

	return commentBuffer;

}

// Generates CSV headers on first run and logs values to the SD card (if data available)

bool dataWasReady = false;

void sensordata_logvalues() 

{

	// Generate CSV header after we have queried all slaves once

	if(slavesensors_dataReady()) 

	{

	if(atOK == 0)

	{

		led_on(LED_CYCLE);

		serial0_sendString("ATND");

		serial0_sendChar(0x0D);

		// Scan data end when newline by itself ("")	

		int lineCount = 0;	

		while(1) 

		{

			// Wait for scan to complete. If we timeout, return.

			{

				return;

			}

			bufPtr = serial0_readLine();

			// If we're starting a new block but got a newline instead, we're done!

			if(lineCount == 0 && strcmp(bufPtr, "") == 0) 

			{

				break;			

			}

			{

				strncpy(slaveAddressHigh[nodeCount],bufPtr, 9);

			}

			else if(lineCount == 2) 

			{

				strncpy(slaveAddressLow[nodeCount],bufPtr, 9);

			}

			else if(lineCount == 3) 

			{

				strncpy(slaveNames[nodeCount], bufPtr, 15);

			}

			if(lineCount == 9) 

			{

				if(strcmp(slaveNames[nodeCount], XBEE_LOGDEST_NAME) == 0)

				{

					// Save logger address in the loggerAddressXXXX variables

					strncpy(loggerAddressHigh, slaveAddressHigh[nodeCount], 9);

					strncpy(loggerAddressLow, slaveAddressLow[nodeCount], 9);

					lineCount = 0;

					// don't increment, just overwrite this next time

				}

				else {

					// bufPtr should be null at this point, because we read in a newline after one chunk

	{

		snprintf(debugBuf, 64, "  %s - %s%s (%u)\r\n", slaveNames[i],slaveAddressHigh,slaveAddressLow[i], i);

		serial0_sendString(debugBuf);

	}

	serial0_sendString("\r\n");

	if(atOK != 0) 

	{

		serial0_sendString("AT mode failed \r\n");

	}

	#endif

	_delay_ms(100);

	slavesensors_selectlogger();

	serial0_ion();

}

//#define DEBUG_CONTEXTSWITCH

//#define DEBUG_SELECTNODE

uint8_t selectedNode = 255;

	if(loggerAddressLow[0] != 0x00) 

	{

		slavesensors_selectaddress(loggerAddressHigh,loggerAddressLow);

	}	

}

void slavesensors_exitAT() 

{

	// Exit AT

	serial0_sendString("ATCN");

	serial0_sendChar(0x0D);

	{

		return;

	}

	xbeeIsOk();

}

bool waitTimeout(uint32_t timeout) {

	uint32_t scanStart = time_millis();

	uint32_t lastBlink = 0;

	while(!serial0_hasChar())

	{

	serial0_ioff(); // interrupts MUST be off

	// Enter AT mode

	serial0_sendChar('+'); // Enter AT mode

	serial0_sendChar('+');

	serial0_sendChar('+');

	return xbeeIsOk();

}

int xbeeIsOk() 

{

		error_log(ERROR_XBEETIMEOUT, true);

		return 1;

	}

	char* tmppntr = serial0_readLine();

	if(strcmp(tmppntr, "OK") == 0)

	{

		return 0;

	}

	else

	{

		error_log(ERROR_SLAVETIMEOUT, true);

		return 1;

// TODO: inline. static.

uint32_t beginRequest = 0;

void slavesensors_request() 

{

	slavesensors_selectnode(currentSlave);

	beginRequest = time_millis();

	serial_sendCommand("@"); // Request data!

}

uint8_t numReadingsToExpect = 0; // number of values that the slave is about to send

void gotoNextSlaveOrSensor(bool fail) {

	// If we finished all sensors for all slaves

	if(currentSlave >= (nodeCount-1) && currentSlaveSensor >= (numReadingsToExpect-1))

	{

		#ifdef DEBUG_GETSLAVEDATA

		serial0_sendString("We got all data for all slaves!\r\n");

		#endif

		dataReady = true;

		currentSlave = 0;

		currentSlaveSensor = 0;

	}

	// 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;

	}

}

void slavesensors_process(uint8_t parseResult) 

{

	if(!requesting) 

	{

		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 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);

			char* msg[128];

			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 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

			#endif 

			gotoNextSlaveOrSensor(false);

		}

	}

	// If fail, try retransmit. Or we could skip and hit it next time.

	// TODO: Maximum number of retransmissions

	else if(parseResult == PARSERESULT_FAIL) 

	{

		if(requesting) 

		{

			slavesensors_request();	// re-request

		}			

	}

	else if(parseResult == PARSERESULT_STILLPARSING)

	{

		return; // do nothing

	}

	else 

	{

		return;

	}

}