* Kyle Ripperger

 * Matthew Kroening

 *

 */

#ifndef CONFIG_H_

#define CONFIG_H_

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

// Module config (master.c)

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

#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

 *  Author: kripperger

 */ 

#include <inttypes.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include "../config.h"

#include <util/delay.h>

#include "boardtemp.h"

#include "i2c.h"

void sensors_readBoardTemp()

{

	boardTemp = i2c_read(BOARDTEMP_ADDR, 0x00);		// Read only the first byte of data (we don't need the resolution here)

	boardTemp = ((boardTemp*18)/10) + (32);			// Converting Celsius to Fahrenheit

	boardTemp = boardTemp - 3;						// Linear offset

}

int8_t sensors_getBoardTemp(void)

{

	return boardTemp;

}

*

* Created: 11/15/2012 12:02:38 PM

*  Author: mkanning

*/

#include <stdbool.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include "gps.h"

#include "serial.h"

#include "../config.h"

#include "led.h"

// Circular buffer for incoming data

uint8_t nmeaBuffer[NMEABUFFER_SIZE];

// Location of parser in the buffer

uint8_t nmeaBufferParsePosition = 0;

// Location of receive byte interrupt in the buffer

volatile uint16_t nmeaBufferDataPosition = 0;

// holds the byte ALREADY PARSED. includes starting character

int bytesReceived = 0;

//data (and checksum) of most recent transmission

char data[16];

//used to skip over bytes during parse

int skipBytes = 0;

//used to index data arrays during data collection

int numBytes = 0;

	return course;

}

char dayofmonth[9];	//ddmmyy

char* get_dayofmonth() {

	return dayofmonth;

}

char variation[9];	//xxx.xb

int calculatedChecksum;

int receivedChecksum;

// transmission state machine

enum decodeState {

	//shared fields

	INITIALIZE=0,

	GET_TYPE,

	GPS_CHECKSUM,	//XOR of all the bytes between the $ and the * (not including the delimiters themselves), written in hexadecimal

	//GGA data fields

	GGA_TIME,

	GGA_LATITUDE,

	GGA_LONGITUDE,

	GGA_QUALITY,

	GGA_SATELLITES,

				#ifdef DEBUG_NMEA

				serial0_sendString("found lat skip byte\r\n");

				#endif

				skipBytes = 1;

				setParserState(GGA_LATITUDE);

			}

			else if (byte == ',') //end of this data type

			{

				latitude[7] = 0x00; // null terminate

				setParserState(GGA_LONGITUDE);

				skipBytes = 0; //prep for next phase of parse

				numBytes = 0;

			}

			else //store data

			{

				#ifdef DEBUG_NMEA

				serial0_sendString("found lat byte\r\n");

				#endif

				latitude[numBytes] = byte; //adjust number of bytes to fit array

				numBytes++;

// Turn the specified LED on

void led_on(uint8_t led) 

{

	*(ledList[led].port) |= (1<<ledList[led].pin);

}

	// Turn the specified LED off

void led_off(uint8_t led) 

{

	*(ledList[led].port) &= ~(1<<ledList[led].pin);

}

// Flashes error LED a set amount of times, then leaves it on

void led_errorcode(uint8_t code) 

{

	_delay_ms(400);

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

	{

		led_on(LED_ERROR);

		_delay_ms(150);

		led_off(LED_ERROR);

		_delay_ms(150);

	}

	_delay_ms(400);

	led_on(LED_ERROR);

}

	{&DDRD, &PORTD, PD6}, // SIDEBOARD

	{&DDRD, &PORTD, PD5}, // ACTIVITY

	{&DDRD, &PORTD, PD4}, // CYCLE

	{&DDRA, &PORTA, PD6}, // HEAT

};

#define NUM_LEDS 11

void led_setup();

void led_on(uint8_t led);

void led_off(uint8_t led);

void led_errorcode(uint8_t code);

#endif /* LED_H_ */

struct partition_struct* partition;

struct fat_fs_struct* fs;

struct fat_dir_entry_struct directory;

struct fat_dir_struct* dd;

struct fat_file_struct* fd;

void logger_setup()

{

	if(!sd_raw_init())

	{

		// Initializing SD card failed!

		serial0_sendString("SD> Error initializing.\r\n");

		led_errorcode(ERROR_SD_INIT);

		return;

	}

	// TODO: Check SD card switch to see if inserted.

	// this was included in the library, but is commented out right now

	// Open first partition

	partition = partition_open(sd_raw_read, sd_raw_read_interval, sd_raw_write, sd_raw_write_interval, 0);

	// Check that partition was created correctly

	if(!partition)

	{

		serial0_sendString("SD> Error opening partition.\r\n");

		// Error opening partition. MBR might be screwed up.

		led_errorcode(ERROR_SD_PARTITION);

		return;

	}

	// Open FAT filesystem

	fs = fat_open(partition);

	if(!fs)

	{

		// opening filesystem failed

		led_errorcode(ERROR_SD_PARTITION);

 * 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() 

{

char* bufPtr = 0x00;

char debugBuf[64];

char slaveAddressLow[6][9];

char slaveAddressHigh[6][9];

uint8_t loggerIndex = 255;

void slavesensors_network_scan() {

	serial0_ioff();

	int atOK;

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

	_delay_ms(500); // xbee warmup

	wdt_reset();

	atOK = slavesensors_enterAT();

	char nameString[20] = "NONE";

	char slaveNames[6][16]; // Hold 16-char addresses of max 6 nodes, we only need them for debug so they are local 

	uint8_t nodeCount = 0;

	// wait for OK

	//todo

	if(atOK == 0)

	{

		serial0_sendString("ATND");

		serial0_sendChar(0x0D);

		// wait for scan to complete

		uint16_t scanStart = time_millis(); 		

		while(!serial0_hasChar()) {

			if(time_millis() - scanStart > 5000) {

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

				strcpy(slaveAddressHigh[nodeCount], bufPtr);

			}

			else if(lineCount == 2) {

				strcpy(slaveAddressLow[nodeCount], bufPtr);

			}

			else if(lineCount == 3) {

				lineCount = 0;

			}

			else {

				lineCount++;

			}

		}		

		slavesensors_exitAT();

	}

	led_on(LED_SIDEBOARD);

	_delay_ms(200);

	led_off(LED_SIDEBOARD);

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

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

		snprintf(debugBuf, 64, "  %s - %s%s\r\n", slaveNames[i],slaveAddressHigh,slaveAddressLow[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;

		}

	}

	slavesensors_loggerdest();

	serial0_ion();

}

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

	serial1_ioff();

	while(1)

    {

		// Periodic: LED execution indicator

		if(time_millis() - lastLedCycle > LEDCYCLE_RATE) {

			if(!afsk_busy())

				serial1_ion();

			lastLedCycle = time_millis();	

		}

		// Periodic: Logging

		if(time_millis() - lastLog > LOGGER_RATE) 

		{

			led_on(LED_CYCLE);

			heater_regulateTemp();