#define ERROR_ATFAIL 3

#define ERROR_EXITAT 8

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

// Slave Sensors config (slavesensors.c)

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

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

#define MAX_NUM_SENSORS 20 // 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

// Public broadcast address

#define BROADCAST_ADDR 0 

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

// GPS config (xxx.c)

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

#define NMEABUFFER_SIZE 150

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

// USART config (serial.c)

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

#define USART0_BAUDRATE 115200

#define USART1_BAUDRATE 115200

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

// AX.25 config (ax25.c)

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

// TX delay in milliseconds

#define TX_DELAY      500

#include <avr/pgmspace.h>

#include <avr/sleep.h>

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

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

	{

		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)

	{

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

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

	// TODO: Catch errors here

	if(fat_create_file(dd, filename, &directory) == 0) {

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

/*

 * Master Firmware: Sensor Data

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include "../config.h"

#include <stdio.h>

#include <stdbool.h>

#include "sensordata.h"

#include "slavesensors.h"

#include "boardtemp.h"

#include "looptime.h"

#include "gps.h"

void sensordata_setup() 

{

	for(int i=0; i<MAX_NUM_SLAVES; i++) {

		for(int j=0; j<MAX_NUM_SENSORS; j++) {

		}

	}

}

{

	if(nodeID < MAX_NUM_SLAVES) {

		slaves[nodeID][type] = value;

	}	

}

{

	// Avoid reading out of bad places!

	if(nodeID < MAX_NUM_SLAVES) {

		return slaves[nodeID][type];

	}

	else {

		return 0;

	}

}

char commentBuffer[128];

// [A-30.5 B45.64 C99542]"

char* slavesensors_getAPRScomment() {

	snprintf(commentBuffer,128, "T%d S%s V%s H%s", sensors_getBoardTemp(), get_sv(), get_speedKnots(), get_hdop());

	return commentBuffer;

}

bool dataWasReady = false;

void sensordata_logvalues() {

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

	if(slavesensors_dataReady()) {

		// Only generate/write header the first time data is ready

		if(!dataWasReady) {

			csvHeader[0] = 0x00;

			// Add master data headers

			// Add slave data headers

			for(uint8_t i=0; i<MAX_NUM_SLAVES; i++) {

				for(uint8_t j=0; j<MAX_NUM_SENSORS; j++) {

						// FIXME: will the 128 here really provide safety? might want to subtract the strlen

					}

				}

			}

			// Terminate header string and write to SD card

			logger_log(csvHeader);

			dataWasReady = true;

		}

		// Write CSV sensor values to SD card

		logbuf[0] = 0x00;

		for(int i=0; i<MAX_NUM_SLAVES; i++) {

			for(int j=0; j<MAX_NUM_SENSORS; j++) {

				}

			}

		}

		logger_log(logbuf);

	}

}

/*

 * Master Firmware: Sensor Data

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#ifndef SENSORDATA_H_

#define SENSORDATA_H_

#include "slavesensors.h"

void sensordata_setup();

char* slavesensors_getAPRScomment();

void sensordata_logvalues();

#endif /* SENSORDATA_H_ */

// Location of receive byte interrupt in the buffer

volatile uint16_t bufferDataPosition = 0;

// Parser state

uint8_t parserState = STATE_RESET;

uint8_t lastParserState = STATE_RESET;

// Length of current payload data (and checksum)

uint8_t payloadLength = 0;

// Data and checksum of most recent transmission

char receivedPayload[MAX_PAYLOAD_LEN];

// Payload type ID of the sensor of most recent transmission

char receivedPayloadType = 0;

// Checksum to be calculated and then compared to the received checksum

char checksumCalc = 0;

// Accessors

uint8_t getPayloadLength() 

{

	return payloadLength;

}

{

	return receivedPayload;

}

uint8_t getPayloadType() {

	return receivedPayloadType;

}

// Could inline if program space available

static void setParserState(uint8_t state)

{

	lastParserState = parserState;

	parserState = state;

	// If resetting, clear vars

	if(state == STATE_RESET) 

	{

		payloadLength = 0;

		checksumCalc = 0;

	}

	// Every time we change state, we have parsed a byte

	bufferParsePosition = (bufferParsePosition + 1) % BUFFER_SIZE;

}

#ifndef SERPARSER_H_

#define SERPARSER_H_

enum parseResults

{

	PARSERESULT_FAIL = 0,

	PARSERESULT_NODATA,

	PARSERESULT_STILLPARSING,

	PARSERESULT_PARSEOK,

};

// Parser states

enum parseStates

{

	STATE_RESET = 0,

	STATE_GETDATATYPE,

	STATE_GETDATA,

	STATE_GETCHECKSUM,

};

// Accessors

uint8_t getPayloadLength();

uint8_t getPayloadType();

// Prototypes

int serparser_parse(void);

#endif /* SERPARSER_H_ */

const char label_1[] PROGMEM = "HeaterStatus";

const char label_2[] PROGMEM = "BatteryLevel";

const char label_3[] PROGMEM = "AirTemp";

const char label_4[] PROGMEM = "AmbientLight";

const char label_5[] PROGMEM = "Humidity";

const char label_6[] PROGMEM = "Pressure";

const char label_7[] PROGMEM = "Altitude";

const char label_8[] PROGMEM = "CPM-Radiation";

const char *const labelLookup[] PROGMEM =

{

	label_0,

	label_1,

	label_2,

	label_3,

	label_4,

	label_5,

	label_6,

	label_7,

	label_8,

};

char labelBuffer[25]; // Size to length of label

char* slavesensors_getLabel(uint8_t sensorID) {

}

uint8_t currentSlave = 0;

uint8_t currentSlaveSensor = 0;

bool requesting = false;

void slavesensors_setup() 

{

}

//#define DEBUG_NETWORKSCAN

char* bufPtr = 0x00;

static char slaveAddressLow[MAX_NUM_SLAVES][9];

static char slaveAddressHigh[MAX_NUM_SLAVES][9];

static char slaveNames[MAX_NUM_SLAVES][20];

uint8_t loggerIndex = 255;

uint8_t nodeCount = 0;

bool dataReady = false;

char* slavesensors_slavename(uint8_t id) {

	return slaveNames[id];

}

void slavesensors_network_scan() {

	serial0_ioff();

	int atOK;

	#ifdef DEBUG_OUTPUT

	serial0_sendString("Beginning network scan...\r\n\r\n");

	#endif

	if(!requesting) {

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

		return;

	}

	// TODO: timeout. If we're at NODATA for a long time and we are requesting, that's an issue.

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

	}

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

		uint8_t type = getPayloadType();

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

			// If we finished all sensors for all slaves

#include "lib/gps.h"

#include "lib/i2c.h"

#include "lib/boardtemp.h"

#include "lib/heater.h"

#include "lib/looptime.h"

#include "lib/slavesensors.h"

#include "lib/serparser.h"

#include "lib/sensordata.h"

int main(void)

{

	// Initialize libraries

	time_setup();

	watchdog_setup(); // enables interrupts

	led_setup();

	gps_setup();

	serial0_setup();

	serial1_setup();

	i2c_init();

	sensordata_setup(); // must happen before slavesensors/logger/AFSK

	slavesensors_setup();

	logger_setup();

	afsk_setup();

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

	// Blocking ZigBee node discovery

	slavesensors_network_scan();

	// Software timers	

	uint32_t lastAprsBroadcast = 0;

	uint32_t lastLog = 0;

	uint32_t lastLedCycle = 0;

	uint32_t lastDataReq = 0;

	// Result of last parser run

	int parseResult = PARSERESULT_NODATA;

	// FIXME: Probably don't need this.

	serial1_ioff();

	while(1)

    {

		// Periodic: LED execution indicator

		if(time_millis() - lastLedCycle > LEDCYCLE_RATE) {

			led_spin();