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

char longitudeTmp[9];

char* get_longitudeTrimmed() 

{

	strncpy(longitudeTmp, &longitude[0], 8);

	longitudeTmp[8] = 0x00;

	return longitudeTmp;

}

char* get_longitudeLSBs()

{

	strncpy(longitudeTmp, &longitude[8], 3);

	longitudeTmp[3] = 0x00;

	return longitudeTmp;

}

char quality;		//quality for GGA and validity for RMC

char numSatellites[4];

char* get_sv() 

{

	return numSatellites;

}

char hdop[6];		//xx.x

char* get_hdop() 

{

	return hdop;

}

char altitude[10];	//xxxxxx.x

char wgs84Height[8];	//sxxx.x

char lastUpdated[8];	//blank - included for testing

char stationID[8];	//blank - included for testing

char checksum[3];	//xx

char knots[8];		//xxx.xx

char* get_speedKnots() 

{

	return knots;

}

char course[8];		//xxx.x

char* get_course() 

{

	return course;

}

char dayofmonth[9];	//ddmmyy

char* get_dayofmonth() 

{

	return dayofmonth;

}

bool gps_hadfix = false;

bool gps_hasfix() 

{

	bool hasFix = get_latitudeTrimmed()[0] != 0x00;

	if(hasFix && !gps_hadfix) {

	}

	else if(!hasFix && gps_hadfix) {

	}

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

{

	timestamp[0] = 0x00;

	latitude[0] = 0x00;

	longitude[0] = 0x00;

	numSatellites[0] = 0x00;

	hdop[0] = 0x00;

	knots[0] = 0x00;

	course[0] = 0x00;

	dayofmonth[0] = 0x00;

}

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

/*

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

#define COMMENTBUFFER_SIZE 128

char commentBuffer[COMMENTBUFFER_SIZE];

char* slavesensors_getAPRScomment() 

{

	snprintf(commentBuffer,COMMENTBUFFER_SIZE, "t9%d s%s v%s h%s _%s |%s ", sensors_getBoardTemp(), get_sv(), get_speedKnots(), get_hdop(), get_latitudeLSBs(), get_longitudeLSBs());

	// Find slave sensors to include in this log

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

	{

		uint32_t val = sensordata_get(i, SENSOR_BOARDTEMP);

		if(val != -2111111111) {

			uint16_t len = strlen(commentBuffer);

			snprintf(commentBuffer + len, COMMENTBUFFER_SIZE-len, " t%u%li",i,val);

		}

		val = sensordata_get(i, SENSOR_PRESSURE);

		if(val != -2111111111) {

			uint16_t len = strlen(commentBuffer);

			snprintf(commentBuffer + len, COMMENTBUFFER_SIZE-len, " P%li",val);

		}

		val = sensordata_get(i, SENSOR_AIRTEMP);

		if(val != -2111111111) {

			uint16_t len = strlen(commentBuffer);

			snprintf(commentBuffer + len, COMMENTBUFFER_SIZE-len, " C%li",val);

		}

	}

	if(logger_aprsInfoTextAvailable())

	{

		uint16_t len = strlen(commentBuffer);

		snprintf(commentBuffer + len, COMMENTBUFFER_SIZE-len, " %s",logger_getAprsInfoText());

		logger_aprsInfoTextConsumed();

	}

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

		logbuf[0] = 0x00;

		// Write master sensor values

		snprintf(logbuf, CSV_LOGLINE_SIZE, "%lu,%d,%s,%s,%s,%s,%s,%s,%s,", time_millis(), sensors_getBoardTemp(),get_timestamp(),get_latitudeTrimmed(),get_longitudeTrimmed(),get_speedKnots(),get_hdop(), get_course(), get_sv());

		// Write slave sensor values

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

		{

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

			{

				int32_t tmp = sensordata_get(i, j);

				// If a sensor value exists, log the data

				if(tmp != -2111111111) 

				{

					snprintf(logbuf + strlen(logbuf),CSV_LOGLINE_SIZE-strlen(logbuf)," %ld,", tmp);

				}

			}

		}

		// End line and write to log

		snprintf(logbuf + strlen(logbuf),CSV_LOGLINE_SIZE-strlen(logbuf),"\r\n");

		logger_log(logbuf);

	}

}