/*

 * Master Firmware: APRS

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include "../config.h"

#include "aprs.h"

#include "ax25.h"

#include "gps.h"

#include <stdio.h>

const char *gps_aprs_lat = "39.74744N";

const char *gps_aprs_lon = "-83.81249W";

const char *gps_time = "081533/";

float gps_altitude = 123.5;

int gps_course = 5;

int gps_speed = 13;

float meters_to_feet(float m)

{

  // 10000 ft = 3048 m

  return m / 0.3048;

}

void aprs_send()

{

  char temp[12];                   // Temperature (int/ext)

  const struct s_address addresses[] = { 

    {D_CALLSIGN, D_CALLSIGN_ID},  // Destination callsign

    {S_CALLSIGN, S_CALLSIGN_ID},  // Source callsign (-11 = balloon, -9 = car)

#ifdef DIGI_PATH1

    {DIGI_PATH1, DIGI_PATH1_TTL}, // Digi1 (first digi in the chain)

#endif

#ifdef DIGI_PATH2

    {DIGI_PATH2, DIGI_PATH2_TTL}, // Digi2 (second digi in the chain)

#endif

  };

	// emz: modified this to get the size of the first address rather than the size of the struct itself, which fails

  ax25_send_header(addresses, sizeof(addresses)/sizeof(addresses[0]));

  ax25_send_byte('/');                // Report w/ timestamp, no APRS messaging. $ = NMEA raw data

  // ax25_send_string("021709z");     // 021709z = 2nd day of the month, 17:09 zulu (UTC/GMT)

  ax25_send_string(get_dayofmonth()); ///! Needs to be day hour minute        // 170915 = 17h:09m:15s zulu (not allowed in Status Reports)

  ax25_send_string(get_timestamp()); 

  ax25_send_byte('z'); // zulu time. h for nonzulu

  ax25_send_string(get_latitude());     // Lat: 38deg and 22.20 min (.20 are NOT seconds, but 1/100th of minutes)

  ax25_send_byte('N');

  ax25_send_byte('/');                // Symbol table

  ax25_send_string(get_longitude());     // Lon: 000deg and 25.80 min

  ax25_send_byte('W');

  ax25_send_byte('O');                // Symbol: O=balloon, -=QTH

  snprintf(temp, 4, "%03d", (int)(gps_course + 0.5)); 

  ax25_send_string(temp);             // Course (degrees)

  ax25_send_byte('/');                // and

  //snprintf(temp, 4, "%03d", (int)(gps_speed + 0.5));

  ax25_send_string(get_speedKnots());             // speed (knots)

  /*

  ax25_send_string("/A=");            // Altitude (feet). Goes anywhere in the comment area

  snprintf(temp, 7, "%06ld", (long)(meters_to_feet(gps_altitude) + 0.5));

  ax25_send_string(temp);

  ax25_send_string("/Ti=");

  snprintf(temp, 6, "%d", 122);//sensors_int_lm60()); -- PUT SENSOR DATA HERE

  ax25_send_string(temp);

  ax25_send_string("/Te=");

  snprintf(temp, 6, "%d", 123);//sensors_ext_lm60());

  ax25_send_string(temp);

  ax25_send_string("/V=");

  snprintf(temp, 6, "%d", 123);//sensors_vin());

  ax25_send_string(temp);

  */

  ax25_send_byte(' ');

  ax25_send_footer();

  ax25_flush_frame();                 // Tell the modem to go

}

#include "gps.h"

#include "serial.h"

#include "../config.h"

#include "led.h"

// Circular buffer for incoming data

uint8_t nmeaBuffer[NMEABUFFER_SIZE];

// Location of parser in the buffer

uint8_t nmeaBufferParsePosition = 0;

// Location of receive byte interrupt in the buffer

volatile uint16_t nmeaBufferDataPosition = 0;

// holds the byte ALREADY PARSED. includes starting character

int bytesReceived = 0;

//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* get_latitude() {

	return latitude;

}

char longitude[14];	//yyyyy.yyb

char* get_longitude() {

	return longitude;

}

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

char numSatellites[4];

	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;

}

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;

}

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

			}		

			else {

				setParserState(INITIALIZE);

			}

/*

 * gpsMKa.h

 *

 * Created: 11/15/2012 12:02:53 PM

 *  Author: mkanning

 */ 

#ifndef GPSMKA_H_

#define GPSMKA_H_

#define GGA_MESSAGE

#define RMC_MESSAGE

#define UKN_MESSAGE

char* get_longitude();

char* get_latitude();

char* get_timestamp();

char* get_speedKnots();

char* get_course();

char* get_hdop();

char* get_dayofmonth();

#endif /* GPSMKA_H_ */

/*

 * Master Firmware: Sensor Data

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include "../config.h"

#include "sensordata.h"

int16_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] = -32768; // minimum value of 16 bit integer

		}

	}

}

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

{

	if(nodeID < MAX_NUM_SLAVES) {

		slaves[nodeID][type] = value;

	}	

}

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

	}

}

/*

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

void sensordata_set(uint8_t nodeID, uint8_t type, uint16_t value);

int16_t sensordata_get(uint8_t nodeID, uint8_t type);

void sensordata_setBoardTemp(uint8_t slaveID, int16_t value);

int16_t sensordata_getBoardTemp(uint8_t slaveID);

#endif /* SENSORDATA_H_ */

void slavesensors_exitAT() 

{

	// Exit AT

	serial0_sendString("ATCN");

	serial0_sendChar(0x0D);

	xbeeIsOk(); // wait for OK

}

// Enter AT mode. Leaves "OK" on the buffer.

int slavesensors_enterAT() 

{

	// Delay guard time

	_delay_ms(1);

	// Enter AT mode

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

	serial0_sendChar('+');

	serial0_sendChar('+');

	// Wait 1ms until we get "OK"

	int atStart = time_millis();

	while(!serial0_hasChar()) {

		if(time_millis() - atStart > 500) {

			led_errorcode(ERROR_XBEETIMEOUT);

			wdt_reset();

			return 1;

		}

	};	

	return xbeeIsOk();

}

int xbeeIsOk() 

{

	char* tmppntr = serial0_readLine();

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

	{

		return 0;

	}

	else

	{

		led_errorcode(ERROR_NOXBEE);

		return 1;

	}

}

bool slavesensors_isrequesting() 

{

	return requesting;	

}

void slavesensors_startprocess() 

{

	requesting = true;

	slavesensors_request();		

}

// TODO: inline. static.

void slavesensors_request() 

{

	//slavesensors_selectnode(currentSlave);

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

}

int numReadingsToExpect = 0; // number of values that the slave is about to send (testing)

// TODO: needs to skip logger!

void slavesensors_process(uint8_t parseResult) 

{

	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.

	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)

	{

		// We got some data, let's handle it

		// ASCII payload

		uint8_t len = getPayloadLength();

		uint8_t* load = getPayload();

		uint8_t type = getPayloadType();

		uint16_t parsedVal = atoi(load);

		// Special case for slave telling us how many things we're about to get		

		if(type + 0x30 == '@') {

			serial0_sendString("Got an awesome count!\r\n");

/*

 * 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/gps.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)

{

	led_on(LED_POWER);

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

	#ifdef DEBUG_OUTPUT

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

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

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

	#endif

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

	slavesensors_network_scan(); // This can take a little while

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

	logger_log("ProgramTime,LastAprsBroadcast,LastLog\n");

	serial1_ioff();

	while(1)

    {

		// Periodic: LED execution indicator

		if(time_millis() - lastLedCycle > LEDCYCLE_RATE) {

			led_spin();

			if(!afsk_busy())

				serial1_ion();

			lastLedCycle = time_millis();	

		}

		// Periodic: Logging

		if(time_millis() - lastLog > LOGGER_RATE) 

		{

			led_on(LED_CYCLE);

			heater_regulateTemp();

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

			// Turn on sideboard LED if we have a fix

			if(strcmp("99.99", get_hdop()) == 0) {

				led_off(LED_SIDEBOARD);

			}

			else {

				led_on(LED_SIDEBOARD);

			}

			sensors_readBoardTemp(); // i2c read, 400k

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

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

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

					int16_t tmp = sensordata_get(i, j);

					if(tmp != -32768) {

						//serial0_sendString("OH GOSH DATUM\r\n");

						serial0_sendString(logbuf);

					}

				}

			}

			logger_log(logbuf);

			// Print out logger debug

			#ifdef DEBUG_OUTPUT

			//serial0_sendString("LOG> ");

			//serial0_sendString(logbuf);

			#endif

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

    }

}