/*

 * Master Firmware: Configuration

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#ifndef CONFIG_H_

#define CONFIG_H_

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

// Module config (master.c)

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

#define F_CPU 11059200

#define MODULE_ID '1'

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

// Error Codes config (led.c, used throughout code)

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

// SD Card

#define ERROR_SD_INIT 2

#define ERROR_SD_PARTITION 3

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

// Slave Sensors config (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

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

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

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

// USART config (serial.c)

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

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

// AX.25 config (ax25.c)

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

// TX delay in milliseconds

#define TX_DELAY      300

// 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   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    "Custom payload data here, eventually..."

// Transmit the APRS sentence every X milliseconds

#define APRS_TRANSMIT_PERIOD 5000

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

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

#endif /* CONFIG_H_ */

/*

 * Master Firmware: Program Timer

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include "../config.h"

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

volatile uint32_t millis = 0; // Milliseconds since initialization

void time_setup() 

{

	DDRA = 0xff;

	// Generic microcontroller config options

	OCR0A = 173; // Approx 172.7969 ticks per ms with 64 prescaler

	TCCR0A |= (1 << WGM01) | (1 << WGM00); // Count until OCR0A, then overflow (wgm02 in the next line specifies this as well)

	TCCR0B |= (1 << CS01) | (1 << CS00) | (1 << WGM02); // clock div by 64

	TIFR0 |= ( 1 << TOV0 ); // clear pending interrupts

	TIMSK0 |= (1 << TOIE0); // enable overflow interrupt

}

ISR(TIMER0_OVF_vect) 

{

	millis = millis + 1;

}

uint32_t time_millis() 

{

	return millis; // meh accuracy, but that's OK

}

/*

 * Master Firmware: Program Timer

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#ifndef LOOPTIME_H_

#define LOOPTIME_H_

void time_setup();

uint32_t time_millis();

#endif /* LOOPTIME_H_ */

/*

 * Master Firmware: Serial Parser

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include <avr/io.h>

#include <avr/interrupt.h>

#include "../config.h"

#include "serial.h"

#include "serparser.h"

#include "led.h"

// Circular buffer for incoming data

uint8_t buffer[BUFFER_SIZE];

// Location of parser in the buffer

uint8_t bufferParsePosition = 0;

// Location of receive byte interrupt in the buffer

volatile uint16_t bufferDataPosition = 0;

// Parser state

uint8_t parserState = STATE_RESET;

uint8_t lastParserState = STATE_RESET;

// Length of current payload data (and checksum)

// Data and checksum of most recent transmission

char receivedPayload[MAX_PAYLOAD_LEN];

// Payload type ID of the sensor of most recent transmission

char receivedDataType = 0;

// Checksum to be calculated and then compared to the received checksum

char checksumCalc = 0;

// Could inline if program space available

static void setParserState(uint8_t state)

{

	lastParserState = parserState;

	parserState = state;

	// If resetting, clear vars

	if(state == STATE_RESET) 

	{

		dataLength = 0;

		checksumCalc = 0;

	}

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

	bufferParsePosition = (bufferParsePosition + 1) % BUFFER_SIZE;

}

// Receive data on USART

char buffmeh[16];

ISR(USART0__RX_vect)

{

	led_on(POWER);

	buffer[bufferDataPosition % BUFFER_SIZE] = UDR0;

	bufferDataPosition = (bufferDataPosition + 1) % BUFFER_SIZE;

}

#define DEBUG

// Parse data from circular buffer

int serparser_parse(void)

{

	char byte;

	// Process first command (if any) on the circular buffer

	while(bufferDataPosition != bufferParsePosition)

	{

		byte = buffer[bufferParsePosition];

		// Reset 

		if(parserState == STATE_RESET)

		{

			if(byte == '[') // Start of frame; keep parsing

			{

				#ifdef DEBUG

				serial0_sendString("start ok\r\n");

				#endif

				setParserState(STATE_GETID);

			}

			else // Not start of frame, reset

			{

				#ifdef DEBUG

				serial0_sendString("not start\r\n");

				#endif

				setParserState(STATE_RESET);

				return PARSERESULT_NODATA; // no valid start bit; better luck next time. run the function the next time around the main loop.

			}

		}

		// Get destination module ID

		else if(parserState == STATE_GETID)

		{

			if(byte == MODULE_ID) // Message intended for this module; keep parsing

			{

				#ifdef DEBUG

				serial0_sendString("dest ok\r\n");

				#endif

				checksumCalc += byte;

				setParserState(STATE_GETDATATYPE);

			}

			else // Transmission is intended for another module; reset

			{

				#ifdef DEBUG

				serial0_sendString("bad dest\r\n");

				#endif

				setParserState(STATE_RESET);

			}

		}

		// Get payload type ID

		else if(parserState == STATE_GETDATATYPE)

		{

			#ifdef DEBUG

			serial0_sendString("type ok\r\n");

			#endif

			receivedDataType = byte; // Store the type of data receiving

			checksumCalc += byte;

			setParserState(STATE_GETDATA);

		}

		// Get payload data

		else if(parserState == STATE_GETDATA)

		{		

			if (byte == ']') // End of frame

			{

				#ifdef DEBUG

				serial0_sendString("eof ok\r\n");

				#endif

				if(bufferParsePosition == bufferDataPosition) 

				{

					// We are at the end of the line. No more data to parse.

					setParserState(STATE_RESET);

					return PARSERESULT_PARSEOK;

				}

				else 

				{

					setParserState(STATE_RESET);

					// we could choose to keep parsing now, or parse the next message next loop around (better idea).

					// return now so we hit it the next time around

					return PARSERESULT_PARSEOK;

				}

			}

			else // Still receiving data

			{

				#ifdef DEBUG

				serial0_sendString("data ok\r\n");

				#endif

				receivedPayload[dataLength] = byte;

				dataLength++;

				checksumCalc += byte;

				// Data buffer overrun protection

				if(dataLength > MAX_PAYLOAD_LEN) {

					#ifdef DEBUG

					#endif

					setParserState(STATE_RESET);

					return PARSERESULT_FAIL;

				}

				else {

					// Set state. MUST call even though state is maintained to update parse position

					setParserState(STATE_GETDATA);

					return PARSERESULT_STILLPARSING;

				}

			}

		}

	}

	return PARSERESULT_NODATA;

}