// NOT USED. Could integrate into slavesensors.c setup function for configurability eventually.

// Currently manual configuration of sensors is done in slavesensors.c

#define SLAVE0_SENSORS BOARDTEMP

#define SLAVE1_SENSORS BOARDTEMP | HUMIDITY | TEMPERATURE | PRESSURE | AMBIENTLIGHT

#define SLAVE2_SENSORS BOARDTEMP | GEIGER

#define SLAVE3_SENSORS BOARDTEMP | CAMERA

#define SLAVE4_SENSORS NONE

#define SLAVE5_SENSORS NONE

#define SLAVE6_SENSORS NONE

#define SLAVE7_SENSORS NONE

// MAX_SLAVES should be one more than the number of slaves we actually have (loop ends when next slave first sensor is NONE)

#define MAX_SLAVES 8

#define MAX_SLAVE_SENSORS 8

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

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

#define BUFFER_SIZE 32 

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

// Maximum packet delay

#define MAX_PACKET_LEN 512  // bytes

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

// APRS config (aprs.c)

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

// Set your callsign and SSID here. Common values for the SSID are

// (from http://zlhams.wikidot.com/aprs-ssidguide):

//

// - Balloons:  11

// - Cars:       9

// - Home:       0

// - IGate:      5

#define S_CALLSIGN      "KD8TDF"

#define S_CALLSIGN_ID   9 // 11

// Destination callsign: APRS (with SSID=0) is usually okay.

#define D_CALLSIGN      "APRS"

#define D_CALLSIGN_ID   0

// Digipeating paths:

// (read more about digipeating paths here: http://wa8lmf.net/DigiPaths/ )

// The recommended digi path for a balloon is WIDE2-1 or pathless. The default

// is pathless. Uncomment the following two lines for WIDE2-1 path:

#define DIGI_PATH1      "WIDE2"

#define DIGI_PATH1_TTL  1

// APRS comment: this goes in the comment portion of the APRS message. You

// might want to keep this short. The longer the packet, the more vulnerable

// it is to noise.

#define APRS_COMMENT    "CU HAB TEST"

// Transmit the APRS sentence every X milliseconds

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

// Logger config (logger.c)

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

#define LOGGER_ID_EEPROM_ADDR 0x10

// Written to the beginning of every log file

#define LOGGER_HEADERTEXT "HAB Control Master - 1.0\n"

// Log to SD card every X milliseconds

#define LOGGER_RATE 1000 

// LED cycle indicator speed

#define LEDCYCLE_RATE 100 

#endif /* CONFIG_H_ */

 * 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 "trackuinoGPS/gpsMKa.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_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_string("SV:");

  ax25_send_string(getNumSatelites());

  ax25_send_byte(' ');

  ax25_send_string(APRS_COMMENT);     // Comment

  ax25_send_footer();

  ax25_flush_frame();                 // Tell the modem to go

}

/*

 * Master Firmware: USART Send/Recieve

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include "serial.h"

#include "led.h"

#include "../config.h"

#include <avr/io.h>

#include <avr/interrupt.h>

// NOTE: USART ISRs for character reception are included in serparser.c

void serial0_setup() {

	//PORTD &= ~(1<<PD0);

	//PORTD |= (1<<PD1);

	/* Enable receiver and transmitter */

	UCSR0B |= (1<<RXEN0)|(1<<TXEN0); // Enable rx/tx

	/* Set frame format: 8data, 1stop bit */

	UCSR0C |= (1 << UCSZ00) | (1 << UCSZ01); // - 1 stop bit

	/* Set baud rate */

	UBRR0H = (unsigned char)(USART0_BAUD_PRESCALE>>8);

	UBRR0L = (unsigned char)USART0_BAUD_PRESCALE;

	UCSR0B |= (1 << RXCIE0); // Enable interrupt

	//UCSR0A |= (1<<RXC0);

}

void serial1_setup() {

//PROVEN in test project

	/* Enable receiver and transmitter */

	UCSR1B |= (1<<RXEN1)|(1<<TXEN1); // Enable rx/tx

	/* Set frame format: 8data, 1stop bit */

	UCSR1C |= (1 << UCSZ10) | (1 << UCSZ11); // - 1 stop bit

	/* Set baud rate */

	UBRR1H = (unsigned char)(USART1_BAUD_PRESCALE>>8);

	UBRR1L = (unsigned char)USART1_BAUD_PRESCALE;

	UCSR1B |= (1 << RXCIE1); // Enable interrupt

}

void serial0_sendChar( unsigned char byte )

{

	while (!(UCSR0A & (1<<UDRE0)));

	UDR0 = byte;

}

void serial1_sendChar( unsigned char byte )

{

	while (!(UCSR1A & (1<<UDRE1)));

	UDR1 = byte;

}

void serial0_sendString(const char* stringPtr){

	while(*stringPtr != 0x00)

	{

		serial0_sendChar(*stringPtr);

		stringPtr++;

	}

}

void serial1_sendString(const char* stringPtr){

	while(*stringPtr != 0x00)

	{

		serial1_sendChar(*stringPtr);

		stringPtr++;

	}

}

void serial_sendCommand( char moduleID, char sensorID, char* data )

{

	char checkSum = 0x00; //initialize checksum

	serial0_sendChar('['); //bracket indicates start of command

	serial0_sendChar(moduleID);

	checkSum+=moduleID;

	serial0_sendChar(sensorID);

	checkSum+=sensorID;

	// send data, null-terminated

	while(*data != 0x00)

	{

		serial0_sendChar(*data);

		checkSum += *data;

		data++;

	}

/*

 * Master Firmware: USART Send/Recieve

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#ifndef SERIAL_H_

#define SERIAL_H_

#include <inttypes.h>

#define USART0_BAUD_PRESCALE (((F_CPU / (USART0_BAUDRATE * 16UL))) -1 )

#define USART1_BAUD_PRESCALE (((F_CPU / (USART1_BAUDRATE * 16UL))) -1 )

void serial0_sendChar( unsigned char byte );

void serial1_sendChar( unsigned char byte );

void serial0_setup();

void serial1_setup();

void serial0_sendString(const char* stringPtr);

void serial1_sendString(const char* stringPtr);

void serial_sendCommand( char moduleID, char sensorID, char* data );

void serial_sendResponseData();

#endif /* SERIAL_H_ */

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

char* getNumSatelites() {

	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 variation[9];	//xxx.xb

int calculatedChecksum;

int receivedChecksum;

char convertBuf1[15];

char convertBuf2[15];

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

char debugBuff[128];

ISR(USART1_RX_vect)

{

	nmeaBuffer[nmeaBufferDataPosition % NMEABUFFER_SIZE] = UDR1;

	nmeaBufferDataPosition = (nmeaBufferDataPosition + 1) % NMEABUFFER_SIZE;

	//serial0_sendChar(UDR1);

	//snprintf(debugBuff, 32, "GPS: bdp: %d, bpp: %d decodestate: %u \r\n", nmeaBufferDataPosition, nmeaBufferParsePosition, decodeState);

	//serial0_sendString((debugBuff));

}

		//parse transmission type

		else if (decodeState == GET_TYPE)

		{

			tramsmissionType[numBytes] = byte;

			numBytes++;

			#ifdef DEBUG_NMEA

			serial0_sendString("stored a type byte\r\n");

			#endif

			if(byte == ',') //end of this data type

			{

				tramsmissionType[5] = 0x00;

				if (tramsmissionType[2] == 'G' &&

				tramsmissionType[3] == 'G' &&

				tramsmissionType[4] == 'A')

				{

					setParserState(GGA_TIME);

					numBytes = 0;

				}

				else if (tramsmissionType[2] == 'R' &&

				tramsmissionType[3] == 'M' &&

				tramsmissionType[4] == 'C')

				{

					setParserState(RMC_TIME);

					numBytes = 0;

				}

				else //this is an invalid transmission type

				{

					setParserState(INITIALIZE);

				}

			}

			else {

				// continue

				setParserState(GET_TYPE);

			}

		}

		///parses GGA transmissions START

		/// $--GGA,hhmmss.ss,llll.ll,a,yyyyy.yy,a,x,xx,x.x,x.x,M,x.x,M,x.x,xxxx*xx

		//timestamp

		else if (decodeState == GGA_TIME)

		{

			if (byte == ',') //end of this data type

			{

				setParserState(GGA_LATITUDE);

				skipBytes = 0; //prep for next phase of parse

				numBytes = 0;

			}

			else //store data

			{

				#ifdef DEBUG_NMEA

				serial0_sendString("found GGA time byte\r\n");

				#endif

				setParserState(GGA_TIME);

				timestamp[numBytes] = byte; //byte; //adjust number of bytes to fit array

				numBytes++;

			}

		}

		//latitude

		else if (decodeState == GGA_LATITUDE)

		{

			if (byte == ',' && skipBytes == 0) //discard this byte

			{

				#ifdef DEBUG_NMEA

				serial0_sendString("found lat skip byte\r\n");

				#endif

				skipBytes = 1;

				setParserState(GGA_LATITUDE);

			}

			else if (byte == ',') //end of this data type

			{

				latitude[7] = 0x00; // null terminate

				// First 2 bytes

				//convertBuf1[0] = latitude[0];

				//convertBuf1[1] = latitude[1];

				//convertBuf1[2] = '\0';

				//strncpy(convertBuf2, latitude, 7);

				//convertBuf2[7] = '\0';

				setParserState(GGA_LONGITUDE);

				skipBytes = 0; //prep for next phase of parse

				numBytes = 0;

			}

			else //store data

			{

				serial0_sendString("found long byte\r\n");

				#endif

				//longitude[numBytes]= byte; //adjust number of bytes to fit array

				numBytes++;

				setParserState(RMC_LONGITUDE);

			}

		}

		//knots

		else if(decodeState == RMC_KNOTS)

		{

			if (byte == ',') //end of this data type

			{

				knots[numBytes] = 0x00;

				setParserState(RMC_COURSE);

				numBytes = 0; //prep for next phase of parse

			}

			else //store data

			{

				setParserState(RMC_KNOTS);

				knots[numBytes]= byte; //adjust number of bytes to fit array

				numBytes++;

			}

		}

		//course

		else if(decodeState == RMC_COURSE)

		{

			if (byte == ',') //end of this data type

			{

				course[numBytes] = 0x00;

				setParserState(RMC_DATE);

				numBytes = 0; //prep for next phase of parse

			}

			else //store data

			{

				setParserState(RMC_COURSE);

				course[numBytes] = byte; //adjust number of bytes to fit array

				numBytes++;

			}

		}

		//date

		else if(decodeState == RMC_DATE)

		{

			if (byte == ',') //end of this data type

			{

				setParserState(RMC_MAG_VARIATION);

				skipBytes = 0; //prep for next phase of parse

				numBytes = 0;

			}

			else //store data

			{

				setParserState(RMC_DATE);

				numBytes++;

			}

		}

		//magnetic variation

		else if(decodeState == RMC_MAG_VARIATION)

		{

			if (byte == '*') //end of this data type

			{

				variation[numBytes] = 0x00;

				setParserState(GPS_CHECKSUM);

				numBytes = 0; //prep for next phase of parse

			}

			else //store data

			{

				setParserState(RMC_MAG_VARIATION);

				variation[numBytes] = byte; //adjust number of bytes to fit array

				numBytes++;

			}

		}

		///parses RMC transmissions END

		//checksum

		else if (decodeState == GPS_CHECKSUM)

		{

			if (numBytes == 2) //end of data - terminating character ??

			{

				//checksum calculator for testing http://www.hhhh.org/wiml/proj/nmeaxor.html

				//TODO: must determine what to do with correct and incorrect messages

				receivedChecksum = checksum[0] + (checksum[1]*16);	//convert bytes to int

				if(calculatedChecksum==receivedChecksum)

				{

				}

				else

				{

				}

				#ifdef DEBUG_NMEA

				serial0_sendString("OMG GOT TO CHECKSUM!\r\n");

				#endif

				serial0_sendString((debugBuff));

				setParserState(INITIALIZE);

				numBytes = 0; //prep for next phase of parse

			}

			else //store data

/*

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

#endif /* GPSMKA_H_ */

#include "lib/boardtemp.h"

#include "lib/looptime.h"

#include "lib/slavesensors.h"

#include "lib/serparser.h"

#include "lib/sensordata.h"

int main(void)

{

    _delay_ms(1500); // warmup

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

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

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

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

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

	led_on(LED_POWER);

	led_off(LED_SIDEBOARD);