}

	gps_hadfix = hasFix;

	return 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

	//GGA data fields

	GGA_TIME,

	GGA_LATITUDE,

	GGA_LONGITUDE,

	GGA_QUALITY,

	GGA_SATELLITES,

	GGA_HDOP,

	GGA_ALTITUDE,

	GGA_WGS84,

	GGA_LAST_UPDATE,

	GGA_STATION_ID,

	//RMC data fields

	RMC_TIME,

	RMC_VALIDITY,

	RMC_LATITUDE,

	RMC_LONGITUDE,

	RMC_KNOTS,

	RMC_COURSE,

	RMC_DATE,

	RMC_MAG_VARIATION,

}decodeState;

ISR(USART1_RX_vect)

{

	nmeaBuffer[nmeaBufferDataPosition % NMEABUFFER_SIZE] = UDR1;

	nmeaBufferDataPosition = (nmeaBufferDataPosition + 1) % NMEABUFFER_SIZE;

}

void gps_setup() 

{

}

// Could inline if program space available

static void setParserState(uint8_t state)

{

	decodeState = state;

	// If resetting, clear vars

	if(state == INITIALIZE)

	{

		calculatedChecksum = 0;

	}

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

	nmeaBufferParsePosition = (nmeaBufferParsePosition + 1) % NMEABUFFER_SIZE;

}

//// MKa GPS transmission parser START

void parse_gps_transmission(void){

	// Pull byte off of the buffer

	char byte;

	while(nmeaBufferDataPosition != nmeaBufferParsePosition) 

	{

		led_on(LED_ACTIVITY);

		byte = nmeaBuffer[nmeaBufferParsePosition];

		if(decodeState == INITIALIZE) //start of transmission sentence

		{

			if(byte == '$') 

			{

				#ifdef DEBUG_NMEA

				serial0_sendString("found $\r\n");

				#endif

				setParserState(GET_TYPE);

				numBytes = 0; //prep for next phases

				skipBytes = 0;

				calculatedChecksum = 0;

			}		

	{

		// Error seeking to file

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

		error_log(ERROR_SD_FILE, true);

		fat_close_file(fd_datalog);

		return;

	}

	// Write header information

	logger_log(LOGGER_HEADERTEXT);

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

	error_log_rawwrite(LOGGER_HEADERTEXT);

	error_log_rawwrite("\n-- BEGIN ERROR --\n");

	error_log_rawwrite("\nErrorNo,ErrorMsg,ErrorInfo,\r\n");

}	

void logger_log(char *buffer) 

{

	uint8_t len = strlen(buffer);

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

	{

		// Error writing to file

		return;

	}

}

void error_log(uint8_t errNo, bool flashLED)

{

	char labelBuffer[32];

	labelBuffer[0] = 0x00;

	if(errNo <= MAX_ERRNO) 

	{

		strncpy_P(labelBuffer,(char*)pgm_read_word(&(errorMessageLookup[errNo])),32);

	}

	char errorLine[128];

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

	error_log_rawwrite(errorLine);

	led_on(LED_ERROR);

	if(flashLED) 

	{

		led_errorcode(errNo);

	}	

}

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

{

	char labelBuffer[32];

	labelBuffer[0] = 0x00;

	if(errNo <= MAX_ERRNO)

	{

		strncpy_P(labelBuffer,(char*)pgm_read_word(&(errorMessageLookup[errNo])),32);

	}

	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 info_log_msg(char* infoText)

{

	char errorLine[256];

	snprintf(errorLine, 256, "%lu,8,infotext,%s,\r\n", time_millis(), infoText);

	error_log_rawwrite(errorLine);

}

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;

	}

}

void logger_closeLog() 

{

	fat_close_file(fd_datalog);

	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: Status and Error LED Handler

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#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 info_log_msg(char* infoText);

void error_log_rawwrite(char *buffer);

void logger_log(char *buffer);

void logger_closeLog();

#endif /* LOGGER_H_ */

#include <string.h>

#include "sensordata.h"

#include "slavesensors.h"

#include "boardtemp.h"

#include "looptime.h"

#include "gps.h"

#include "logger.h"

// Slave sensor reading storage

int32_t slaves[MAX_NUM_SLAVES][MAX_NUM_SENSORS];

void sensordata_setup() 

{

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

	{

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

		{

			slaves[i][j] = -2111111111; // minimum value of 16 bit integer

		}

	}

}

// Store a sensor value in memory

void sensordata_set(uint8_t nodeID, uint8_t type, int32_t value)

{

	if(nodeID < MAX_NUM_SLAVES) 

	{

		slaves[nodeID][type] = value;

	}	

}

// Retrieve a sensor value from memory

int32_t sensordata_get(uint8_t nodeID, uint8_t type) 

{

	// Avoid reading out of bad places!

	if(nodeID < MAX_NUM_SLAVES) 

	{

		return slaves[nodeID][type];

	}

	else 

	{

		return 0;

	}

}

// Generate APRS comment

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

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

	{

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

		if(!dataWasReady) 

		{

			#define CSV_BUFFER_SIZE 64

			char csvHeader[CSV_BUFFER_SIZE];

			csvHeader[0] = 0x00;

			// Add master data headers

			logger_log("Time,BoardTemp,GPSTime,GPSLat,GPSLon,GPSSpeed,GPSHDOP,GPSCourse,GPSSV,");

			// Add slave data headers

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

			{

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

				{

					int32_t tmp = sensordata_get(i, j);

					// If a sensor value exists, write a header for it

					if(tmp != -2111111111) 

					{

						snprintf(csvHeader, CSV_BUFFER_SIZE,"%s-%s,", slavesensors_slavename(i), slavesensors_getLabel(j));

						logger_log(csvHeader);

					}

				}

			}

			// End line and write to SD card

			snprintf(csvHeader, CSV_BUFFER_SIZE,"\r\n");

			logger_log(csvHeader);

			dataWasReady = true;

		}

		// Write CSV sensor values to SD card

		#define CSV_LOGLINE_SIZE 512

		char logbuf[CSV_LOGLINE_SIZE];

/*

 * Master Firmware: Slave Sensor Data Acquisition

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include "../config.h"

#include <avr/io.h>

#include <stdbool.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <util/delay.h>

#include <avr/wdt.h>

#include <avr/pgmspace.h>

#include "serial.h"

#include "serparser.h"

#include "slavesensors.h"

#include "sensordata.h"

#include "led.h"

#include "looptime.h"

#include "logger.h"

// Label lookup table

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

const char label_0[] PROGMEM = "BoardTemp";

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[32]; // Size to length of label

char* slavesensors_getLabel(uint8_t sensorID) 

{

	if(sensorID < 9)

	{

		strncpy_P(labelBuffer,(char*)pgm_read_word(&(labelLookup[sensorID])),15);

		return labelBuffer;

	}

	else 

	{

		return NULL;

	}

}

uint8_t currentSlave = 0;

uint8_t currentSlaveSensor = 0;

bool requesting = false;

//#define DEBUG_NETWORKSCAN

//#define DEBUG_GETSLAVEDATA

/*

 * Master Firmware: Slave Sensor Data Aquisition

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#ifndef SLAVESENSORS_H_

#define SLAVESENSORS_H_

#include <stdbool.h>

#include <inttypes.h>

// Serial Commands

enum sensorTypes // CMD ID#

{

};

bool waitTimeout(uint32_t timeout);

char* slavesensors_getLabel(uint8_t sensorID);

char* slavesensors_slavename(uint8_t id);

bool slavesensors_dataReady();

bool slavesensors_isrequesting();

void slavesensors_setup();

void slavesensors_network_scan();

uint8_t slavesensors_getselectednode();

void slavesensors_selectnode(uint8_t nodeIndex);

bool slavesensors_selectaddress(char* addrHigh, char* addrLow);

void slavesensors_startprocess();

void slavesensors_request();

void gotoNextSlaveOrSensor(bool fail);

void slavesensors_process(uint8_t parseResult);

int xbeeIsOk();

void slavesensors_selectlogger();

void slavesensors_exitAT();

int slavesensors_enterAT();

#endif /* SLAVESENSORS_H_ */