/*

 * 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

  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

}

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;

}

	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;

/*

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

			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) 

#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	

		}

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