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

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

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

// Slave Sensors config (slavesensors.c)

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

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

#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.

// 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 <avr/io.h>

#include <stdbool.h>

#include "../config.h"

#include "serial.h"

#include "serparser.h"

#include "slavesensors.h"

#include "led.h"

#include <util/delay.h>

#include <avr/wdt.h>

uint8_t currentSlave = 0;

uint8_t currentSlaveSensor = 0;

uint16_t slaves[MAX_SLAVES][MAX_SLAVE_SENSORS];

bool requesting = false;

void slavesensors_setup() 

{

	// Empty array

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

	{

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

		{

			slaves[i][j] = NONE;

		}			

	}	

	// Slave Configuration

	// slave 0

	slaves[0][0] = BOARDTEMP;

	// slave 1

	slaves[1][0] = BOARDTEMP;

	slaves[1][1] = HUMIDITY;

	slaves[1][2] = TEMPERATURE;

	slaves[1][3] = PRESSURE;

	slaves[1][4] = AMBIENTLIGHT;

	// slave 2

	slaves[2][0] = BOARDTEMP;

	slaves[2][1] = GEIGER;

	// slave 3

	slaves[3][0] = BOARDTEMP;

	slaves[3][1] = CAMERA;

}

char* bufPtr = 0x00;

void slavesensors_network_scan() {

	serial0_ioff();

	int atOK;

	// Enter AT mode

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

	serial0_sendChar('+');

	serial0_sendChar('+');

	bufPtr = serial0_readLine();

	char nameString[20] = "NONE";

	// wait for OK

	//todo

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

	{

		atOK = 1;

		serial0_sendString("ATND");

		serial0_sendChar(0x0D);

		// wait for scan to complete

		while(!serial0_hasChar()) {

			wdt_reset();

		}

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

		int lineCount = 0;	

		while(1) {

			bufPtr = serial0_readLine();

			}

			lineCount++;

		}		

		// Exit AT

		serial0_sendString("ATCN");

		serial0_sendChar(0x0D);

	}

	else {

		atOK = 0;

	}

	_delay_ms(200);

	if(atOK != 1) {

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

	}

	// Wait for response

	// will be multiple values separated by <CR>

	// 9 data lines per node, <CR> terminated, followed by a new line with only <CR> at the end of all nodes.

	// <CR> followed by another <CR> signifies end of scan data

	serial0_ion();

}

bool slavesensors_isrequesting() 

{

	return requesting;	

}

void slavesensors_startprocess() 

{

	requesting = true;

	slavesensors_request();		

}

// TODO: inline. static.

void slavesensors_request() 

{

	serial_sendCommand(currentSlave + 0x30, slaves[currentSlave][currentSlaveSensor] + 0x30, "");

}

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)

	{

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

		// ASCII payload

		uint8_t len = getPayloadLength();

		uint8_t* load = getPayload();

		uint8_t type = getPayloadType();

		// TODO: Check if type matches. if it doesn't, we have a problem...

		uint16_t parsedVal = atoi(load);

		if(slaves[currentSlave][currentSlaveSensor] == BOARDTEMP) {

			sensordata_setBoardTemp(currentSlave, parsedVal);

		}

		else {

			sensordata_set(slaves[currentSlave][currentSlaveSensor], parsedVal);

		}

		// If we finished all sensors for all slaves

		if(slaves[currentSlave+1][0] == NONE && slaves[currentSlave][currentSlaveSensor+1] == NONE) // If next sensor is none and finished all slaves, reset

		{

			currentSlave = 0;

			currentSlaveSensor = 0;

			requesting = false;

		}

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

		else if(slaves[currentSlave][currentSlaveSensor+1] == NONE) 

		{

			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

		{

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

			currentSlaveSensor++;

			requesting = true;

			slavesensors_request();	

		}

	}

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

/*

 * Master Firmware

 *

 * Wireless Observational Modular Aerial Network

 * 

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include "config.h"

#include <avr/io.h>

#include <util/delay.h>

#include <avr/wdt.h>

#include <avr/interrupt.h>

#include <stdio.h>

#include <stdbool.h>

#include "lib/serial.h"

#include "lib/aprs.h"

#include "lib/afsk.h"

#include "lib/led.h"

#include "lib/logger.h"

#include "lib/watchdog.h"

#include "lib/trackuinoGPS/gpsMKa.h"

#include "lib/i2c.h"

#include "lib/boardtemp.h"

#include "lib/looptime.h"

#include "lib/slavesensors.h"

#include "lib/serparser.h"

#include "lib/sensordata.h"

int main(void)

{

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

	// Buffer for string operations

	char logbuf[128];

	char debugBuf[128];

	// Software timers	

	uint32_t lastAprsBroadcast = 0;

	uint32_t lastLog = 0;

	uint32_t lastLedCycle = 0;

	// Result of last parser run

	int parseResult = PARSERESULT_NODATA;

	// Write CSV header to SD card

	logger_log("ProgramTime,LastAprsBroadcast,LastLog\n");

	uint8_t ctr = 0;

	void spin() {

		if(ctr == 0) {

			led_on(LED_ACT0);

			led_off(LED_ACT1);

			led_off(LED_ACT2);

			led_off(LED_ACT3);

		}			

		else if (ctr == 1) {

			led_on(LED_ACT1);

			led_off(LED_ACT0);

			led_off(LED_ACT2);

			led_off(LED_ACT3);

		}			

		else if (ctr == 2) {

			led_on(LED_ACT2);

			led_off(LED_ACT1);

			led_off(LED_ACT0);

			led_off(LED_ACT3);

		}			

		else if (ctr == 3) {

			led_on(LED_ACT3);

			led_off(LED_ACT1);

			led_off(LED_ACT2);

			led_off(LED_ACT0);

		}			

		ctr = (ctr + 1) % 4;

	}

	serial1_ioff();

	while(1)

    {

		// Periodic: LED execution indicator

		if(time_millis() - lastLedCycle > LEDCYCLE_RATE) {

			spin();

			if(!afsk_busy())

				serial1_ion();

			lastLedCycle = time_millis();	

		}

		// Periodic: Logging

		if(time_millis() - lastLog > LOGGER_RATE) 

		{

			led_on(LED_CYCLE);

			// Print out GPS debug

			//serial0_sendString(debugBuf);

			sensors_readBoardTemp(); // i2c read, 400k

			logger_log(logbuf);

			// Print out logger debug

			led_off(LED_CYCLE);

			lastLog = time_millis();

		}		

		// Periodic: APRS transmission

		if(time_millis() - lastAprsBroadcast > APRS_TRANSMIT_PERIOD) 

		{

			while(afsk_busy());

			serial1_ioff();

			aprs_send(); // non-blocking

			//serial0_sendString("Initiating APRS transmission...\r\n");

			// Start getting values for next transmission

			if(slavesensors_isrequesting())

			{

				// TODO: something is terribly wrong

			}

			else 

			{				

				slavesensors_startprocess();

			}

			lastAprsBroadcast = time_millis();

		}			

		parseResult = serparser_parse();

		slavesensors_process(parseResult);

		parse_gps_transmission();

		wdt_reset();

    }

}