#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

 * Master Firmware: USART Send/Recieve

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include "serial.h"

#include "../config.h"

#include <avr/io.h>

void serial0_setup() {

	/* Set baud rate */

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

	UBRR0L = (unsigned char)USART0_BAUD_PRESCALE;

}

void serial1_setup() {

	/* Set baud rate */

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

	UBRR1L = (unsigned char)USART1_BAUD_PRESCALE;

	/* Enable receiver and transmitter */

	UCSR1B = (1<<RXEN1)|(1<<TXEN1);

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

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

}

void serial0_sendChar( unsigned char byte )

{

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include <avr/io.h>

#include "../config.h"

#include "serial.h"

#include "serparser.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;

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

{

	buffer[bufferDataPosition % BUFFER_SIZE] = UDR0;

	bufferDataPosition = (bufferDataPosition + 1) % BUFFER_SIZE;

}

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

			{

				setParserState(STATE_GETID);

			}

			else // Not start of frame, reset

			{

				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

			{

				checksumCalc += byte;

				setParserState(STATE_GETDATATYPE);

			}

			else // Transmission is intended for another module; reset

			{

				setParserState(STATE_RESET);

			}

		}

		// Get payload type ID

		else if(parserState == STATE_GETDATATYPE)

		{

			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

			{

				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

			{

				receivedPayload[dataLength] = byte;

				dataLength++;

				checksumCalc += byte;

				// Data buffer overrun protection

				if(dataLength > MAX_PAYLOAD_LEN) {

					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;

				}

			}

		}

	watchdog_setup();

	led_setup();

	serial0_setup();

	serial1_setup();

	slavesensors_setup();

	logger_setup();

	afsk_setup();

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

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

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

	// Buffer for string operations

	char logbuf[32];

	const char* logBufPtr = logbuf;

	// Software timers	

	uint32_t lastAprsBroadcast = 0;

	uint32_t lastLog = 0;

	// If we are currently processing sensor data

	bool isProcessing = false;

			// TODO: Acquire data from daughterboards

			//       This will be complicated because we need timeouts / unreliable transmission, etc

			//

			// For each daughterboard...

			//   1. Send request to daughterboard for sensor data

			//   2. Wait for response from daughterboard (timeout!)

			//   3. Put data into local variables for transmission / logging

			led_on(STAT);

			snprintf(logbuf, 32, "%lu,%lu,%lu,\r\n", time_millis(), lastAprsBroadcast,lastLog);

			logger_log(logbuf);

			led_off(STAT);

			lastLog = time_millis();

		}		

		// Periodic: APRS transmission

		if(time_millis() - lastAprsBroadcast > APRS_TRANSMIT_PERIOD) 

		{

			while(afsk_busy());

			aprs_send(); // non-blocking

			// Start getting values for next transmission

			isProcessing = true;

			lastAprsBroadcast = time_millis();

		}			

		parseResult = serparser_parse();

		// TODO: If we receive a command, we should still process it even if we aren't isProcessing, right?

		// Maybe we should isolate the received command handling ("Execution") and the issuing of requests.

		wdt_reset();

    }

}