/*

 * 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

#define HEATER_THRESHOLD 70

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

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

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

// Slave Sensors config (slavesensors.c)

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

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

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

// Node identifier of log destination xbee

#define XBEE_LOGDEST_NAME "HAB-LOGGER"

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

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

#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

// 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    "[A-30.5 B45.64 C99542]"

// Transmit the APRS sentence every X milliseconds

#define APRS_TRANSMIT_PERIOD 20000

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

// 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: Slave Sensor Data Aquisition

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include "../config.h"

#include <avr/io.h>

#include <stdbool.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <util/delay.h>

#include <avr/wdt.h>

#include "serial.h"

#include "serparser.h"

#include "slavesensors.h"

#include "sensordata.h"

#include "led.h"

#include "looptime.h"

uint8_t currentSlave = 0;

uint8_t currentSlaveSensor = 0;

bool requesting = false;

void slavesensors_setup() 

{

}

//#define DEBUG_NETWORKSCAN

char* bufPtr = 0x00;

static char slaveAddressLow[MAX_NUM_SLAVES][9];

static char slaveAddressHigh[MAX_NUM_SLAVES][9];

static char slaveNames[MAX_NUM_SLAVES][20];

uint8_t loggerIndex = 255;

uint8_t nodeCount = 0;

bool dataReady = false;

char* slavesensors_slavename(uint8_t id) {

	return slaveNames[id];

}

void slavesensors_network_scan() {

	serial0_ioff();

	int atOK;

	#ifdef DEBUG_OUTPUT

	serial0_sendString("Beginning network scan...\r\n\r\n");

	#endif

	_delay_ms(500); // xbee warmup

	wdt_reset();

	led_on(LED_ACTIVITY);

	atOK = slavesensors_enterAT();

	// wait for OK

	if(atOK == 0)

	{

		led_on(LED_CYCLE);

		serial0_sendString("ATND");

		serial0_sendChar(0x0D);

		// wait for scan to complete

		uint16_t scanStart = time_millis(); 		

		while(!serial0_hasChar()) {

			if(time_millis() - scanStart > 7000) {

				led_errorcode(ERROR_XBEETIMEOUT);

				return;

			}

			wdt_reset();

		}

		// Scan data end when newline by itself ("")	

		int lineCount = 0;	

		while(1) {

			bufPtr = serial0_readLine();

			// If we're starting a new block but got a newline instead, we're done!

			if(lineCount == 0 && strcmp(bufPtr, "") == 0) {

				break;			

			}

			if(lineCount == 1) {

				strncpy(slaveAddressHigh[nodeCount],bufPtr, 9);

			}

			else if(lineCount == 2) {

				strncpy(slaveAddressLow[nodeCount],bufPtr, 9);

			}

			else if(lineCount == 3) {

				strncpy(slaveNames[nodeCount], bufPtr, 20);

			}

			// If we've finished one chunk (including the newline after it). Can't be else if because it controls increment.

			if(lineCount == 9) {

				// bufPtr should be null at this point, because we read in a newline after one chunk

				nodeCount++;

				lineCount = 0;

			}

			else {

				lineCount++;

			}

		}		

		slavesensors_exitAT();

	}

	// Display number of found nodes on spinning indicator

	switch(nodeCount) {

		case 0:

			break;

		case 3:

			led_on(LED_ACT2);

			_delay_ms(100);

		case 2:

			led_on(LED_ACT1);

			_delay_ms(100);	

		case 1:

			led_on(LED_ACT0);

			_delay_ms(100);

	}

	led_on(LED_SIDEBOARD);

	_delay_ms(200);

	led_off(LED_SIDEBOARD);

	#ifdef DEBUG_OUTPUT

	char debugBuf[64];

	serial0_sendString("Discovered: \r\n");

	for(int i=0; i<nodeCount; i++) {

		snprintf(debugBuf, 64, "  %s - %s%s (%u)\r\n", slaveNames[i],slaveAddressHigh,slaveAddressLow[i], i);

		serial0_sendString(debugBuf);

	}

	serial0_sendString("\r\n");

	if(atOK != 0) {

		serial0_sendString("AT mode failed \r\n");

	}

	#endif

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

	{

		if(strcmp(slaveNames[i], XBEE_LOGDEST_NAME) == 0) 

		{

			loggerIndex = i;

		}

	}

	_delay_ms(100);

	slavesensors_selectlogger();

	serial0_ion();

}

void slavesensors_selectnode(uint8_t nodeIndex)

{

	char tmpBuf[23];

	// If we can get into AT mode

	if(slavesensors_enterAT() == 0) {

		snprintf(tmpBuf, 23, "ATDH %s%c",slaveAddressHigh[nodeIndex], 0x0D);

		serial0_sendString(tmpBuf);

		if(xbeeIsOk() != 0) {

			led_errorcode(ERROR_NOXBEE);

			return;

		}

		snprintf(tmpBuf, 23, "ATDL %s%c",slaveAddressLow[nodeIndex], 0x0D);

		serial0_sendString(tmpBuf);

		if(xbeeIsOk() != 0) {

			led_errorcode(ERROR_NOXBEE);

			return;

		}

		slavesensors_exitAT();

	}

	return;

}

void slavesensors_selectlogger() 

{

	if(loggerIndex != 255) {

		slavesensors_selectnode(loggerIndex);

	}	

}

void slavesensors_exitAT() 

{

	// Exit AT

	serial0_sendString("ATCN");

	serial0_sendChar(0x0D);

}

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

int slavesensors_enterAT() 

{

	// Delay guard time

	// Enter AT mode

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

	serial0_sendChar('+');

	serial0_sendChar('+');

	// Wait 1ms until we get "OK"

	return xbeeIsOk();

}

int xbeeIsOk() 

{

	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.

void slavesensors_request() 

{

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

}

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

// 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: timeout. If we're at NODATA for a long time and we are requesting, that's an issue.

	else if(parseResult == PARSERESULT_NODATA) {

		// Wait for data

	}

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

		uint8_t* load = getPayload();

		uint8_t type = getPayloadType();

		uint16_t parsedVal = 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 

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

				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

			}

		}

	}

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

		}			

	}

	else if(parseResult == PARSERESULT_STILLPARSING)

	{

		return; // do nothing

	}

	else {

		// something is terribly wrong!

		return;

	}

}