/*

 * 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 DEBUG_OUTPUT

#define F_CPU 11059200

#define MODULE_ID '1'

#define BOARDTEMP_ADDR 0x90

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

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

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

// SD Card

#define ERROR_SD_INIT 2

#define ERROR_SD_PARTITION 3

#define ERROR_SD_FILE 4

#define ERROR_XBEETIMEOUT 5

#define ERROR_NOXBEE 6

#define ERROR_CRAP 15

#define ERROR_ATFAIL 3

#define ERROR_EXITAT 8

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

// Slave Sensors config (slavesensors.c)

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

#define MAX_NUM_SLAVES 5  // Maximum number of nodes in the system

#define MAX_NUM_SENSORS 10 // Maximum number of unique types of sensors in the system

// Node identifier of log destination xbee

#define XBEE_LOGDEST_NAME "HAB-LOGGER"

#define DATAREQUEST_RATE 3000

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

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

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

#define TX_DELAY      500

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

// Transmit the APRS sentence every X milliseconds

#define APRS_TRANSMIT_PERIOD 20000

/*

 * Master Firmware: Sensor Data

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include "../config.h"

#include <stdio.h>

#include <stdbool.h>

#include <string.h>

#include "sensordata.h"

#include "slavesensors.h"

#include "boardtemp.h"

#include "looptime.h"

#include "gps.h"

#include "logger.h"

// Slave sensor reading storage

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

		}

	}

}

// Store a sensor value in memory

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

{

	if(nodeID < MAX_NUM_SLAVES) 

	{

		slaves[nodeID][type] = value;

	}	

}

// Retrieve a sensor value from memory

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

	}

}

// Generate APRS comment

// TODO: Can we move this buffer to a local scope of this function?

char commentBuffer[128];

char* slavesensors_getAPRScomment() 

{

	snprintf(commentBuffer,128, "T%d S%s V%s H%s _%s |%s", sensors_getBoardTemp(), get_sv(), get_speedKnots(), get_hdop(), get_latitudeLSBs(), get_longitudeLSBs());

	return commentBuffer;

}

// Generates CSV headers on first run and logs values to the SD card (if data available)

bool dataWasReady = false;

void sensordata_logvalues() 

{

	// Generate CSV header after we have queried all slaves once

	if(slavesensors_dataReady()) 

	{

		// Only generate/write header the first time data is ready

		if(!dataWasReady) 

		{

			csvHeader[0] = 0x00;

			// Add master data headers

			// Add slave data headers

			for(uint8_t i=0; i<MAX_NUM_SLAVES; i++) 

			{

				for(uint8_t j=0; j<MAX_NUM_SENSORS; j++) 

				{

					int32_t tmp = sensordata_get(i, j);

					// If a sensor value exists, write a header for it

					if(tmp != -2111111111) 

					{

					}

				}

			}

			// End line and write to SD card

			logger_log(csvHeader);

			dataWasReady = true;

		}

		// Write CSV sensor values to SD card

		logbuf[0] = 0x00;

		// Write master sensor values

		// Write slave sensor values

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

		{

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

			{

				int32_t tmp = sensordata_get(i, j);

				// If a sensor value exists, log the data

				if(tmp != -2111111111) 

				{

				}

			}

		}

		// End line and write to log

		logger_log(logbuf);

	}

}

{

	if(loggerIndex != 255) 

	{

		slavesensors_selectnode(loggerIndex);

	}	

}

void slavesensors_exitAT() 

{

	// Exit AT

	serial0_sendString("ATCN");

	serial0_sendChar(0x0D);

	if(waitTimeout(2000)) 

	{

		return;

	}

	xbeeIsOk();

}

bool waitTimeout(uint32_t timeout) {

	uint32_t scanStart = time_millis();

	uint32_t lastBlink = 0;

	while(!serial0_hasChar())

	{

		if(time_millis() - scanStart > timeout)

		{

			led_errorcode(ERROR_XBEETIMEOUT);

			return true;

		}

		if(time_millis() - lastBlink > 50)

		{

			led_spin();

			lastBlink = time_millis();

		}

		wdt_reset();

	}

	return false;

}

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

int slavesensors_enterAT() 

{

	// Delay guard time

	_delay_ms(2);

	serial0_ioff(); // interrupts MUST be off

	// Enter AT mode

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

	serial0_sendChar('+');

	serial0_sendChar('+');

	return xbeeIsOk();

}

int xbeeIsOk() 

{

	if(waitTimeout(2000)) {

		led_errorcode(ERROR_XBEETIMEOUT);

		return 1;

	}

	char* tmppntr = serial0_readLine();

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

	{

		return 0;

	}

	else

	{

		led_errorcode(ERROR_NOXBEE);

		return 1;

	}

}

bool slavesensors_dataReady() 

{

	return dataReady;

}

bool slavesensors_isrequesting() 

{

	return requesting;	

}

void slavesensors_startprocess() 

{

	requesting = true;

	slavesensors_request();		

}

// TODO: inline. static.

uint32_t beginRequest = 0;

void slavesensors_request() 

{

			return;

		}

	slavesensors_selectnode(currentSlave);

	beginRequest = time_millis();

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

}

uint8_t numReadingsToExpect = 0; // number of values that the slave is about to send

void gotoNextSlaveOrSensor(bool fail) {

	// If we finished all sensors for all slaves

	if(currentSlave >= (nodeCount-1) && currentSlaveSensor >= (numReadingsToExpect-1))

	{

		#ifdef DEBUG_GETSLAVEDATA

		serial0_sendString("We got all data for all slaves!\r\n");

		#endif

		dataReady = true;

		currentSlave = 0;

		currentSlaveSensor = 0;

		requesting = false;

		if(!fail) 

		{

			led_alert();	

		}

	}

	// If we finished up one slave, go to the next

	else if(currentSlaveSensor >= (numReadingsToExpect-1))

	{

		#ifdef DEBUG_GETSLAVEDATA

		serial0_sendString("Finished up one slave, go to another.\r\n");

		#endif

		currentSlave++;

		currentSlaveSensor = 0;

		requesting = true;

		if(currentSlave == loggerIndex)

		{

			if(currentSlave >= (nodeCount-1))

			{

				// We hit the last one, we're done.

				dataReady = true;

				currentSlave = 0;

				currentSlaveSensor = 0;

				requesting = false;

				led_alert();

				return;

			}

			else

			{

			}

		}

		slavesensors_request();

	}

	// If we haven't finished a slave (or all of them), just get the next sensor of the current slave

	else

	{

		#ifdef DEBUG_GETSLAVEDATA

		serial0_sendString("Give me another sensor value...");

		#endif

		// request data for the current sensor of the current slave

		currentSlaveSensor++;

		requesting = true;

		//slavesensors_request();	 slaves now send all values at once, we don't need to keep requesting

	}

}

// 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: If we time out, WE NEED TO RESET THE PARSER. It could be in a bad state.

	else if(parseResult == PARSERESULT_NODATA) 

	{

		// Wait for data

		if(requesting && time_millis() - beginRequest > 1000) {

			// if we're requesting, we have no data, and we're over the timeout, this is bad!

			// setParserState(STATE_RESET); - meh, can't do this because it freaking increments the cirbufptr

			gotoNextSlaveOrSensor(true);

		}

	}

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

	{

		#ifdef DEBUG_GETSLAVEDATA

		char debug[50];

		snprintf(debug, 50, "Slave %u sensor %u of total nodes %u\r\n", currentSlave, currentSlaveSensor,nodeCount);

		serial0_sendString(debug);

		#endif

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

		// ASCII payload

		uint8_t len = getPayloadLength();

		char* load = getPayload();

		uint8_t type = getPayloadType();

		int32_t parsedVal = strtol(load, NULL, 10);//atoi(load);

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

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

		{

			#ifdef DEBUG_GETSLAVEDATA

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

			serial0_sendChar(parsedVal + 0x30);

			serial0_sendString("\r\n");

			#endif

			numReadingsToExpect = parsedVal;

			currentSlaveSensor = 0;

			requesting = true;

		}

		else 

		{

			// Store data in structure

			sensordata_set(currentSlave,type,parsedVal);

			#ifdef DEBUG_GETSLAVEDATA

			serial0_sendString("Stored some sexy data!\r\n");

			#endif 

			gotoNextSlaveOrSensor(false);

		}

	}

	// If fail, try retransmit. Or we could skip and hit it next time.

	// TODO: Maximum number of retransmissions

	else if(parseResult == PARSERESULT_FAIL) 

	{

		if(requesting) 

		{

			slavesensors_request();	// re-request

		}			

	}