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

// Slave Sensors config (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

// Transmit the APRS sentence every X milliseconds

#define APRS_TRANSMIT_PERIOD 5000

// Log to SD card every X milliseconds

#define LOGGER_RATE 1000 

const char *gps_aprs_lat = "omgmylatitude";

const char *gps_aprs_lon = "omgmylongitude";

const char *gps_time = "omgmygpstime";

#include <stdio.h>

#include <util/delay.h>

volatile uint32_t millis = 0; // Milliseconds since initialization

            (1 << SPR10);   // Clock Frequency: f_OSC / 64 which gives over 100khz required minimum clock

unsigned char serial0_readChar()

{

	while(!(UCSR0A &(1<<RXC0)));

	return UDR0;

}

unsigned char serial1_readChar()

{

	while(!(UCSR1A &(1<<RXC1)));

	return UDR1;

}

void serial0_sendString(const char* stringPtr){

void serial1_sendString(const char* stringPtr){

void serial_sendCommand( char moduleID, char sensorID, char* data )

	// send data, null-terminated

	while(*data != 0x00){

		serial0_sendChar(*data);

		checkSum += *data;

		data++;

unsigned char serial0_readChar();

unsigned char serial1_readChar();

void serial0_sendString(const char* stringPtr);

void serial1_sendString(const char* stringPtr);

void serial_sendCommand( char moduleID, char sensorID, char* data );

#include "serial.h"

// TODO: Maybe make this suck up the whole buffer if there is more to be had. That would make this much more efficient.

// we could parse while(SERIAL_RX_HASBYTES && notOverTimeout), don't have it parse for more than 100ms straight or something...

int serparser_parse(void)

		byte = serial0_readChar();

				return 2; // got whole msg

int serparser_parse(void);

/*

 * slavesensors.c

 *

 * Created: 11/27/2012 9:02:12 PM

 *  Author: ethanzonca

 */ 

#include <avr/io.h>

#include <stdbool.h>

#include "../config.h"

#include "serial.h"

#include "serparser.h"

// Serial Commands

enum sensorTypes // CMD ID#

{

	NONE = 0,

	BOARDTEMP = (1<<0),

	PRESSURE = (1<<1),

	GEIGER = (1<<2),

	TEMPERATURE = (1<<3),

	HUMIDITY = (1<<4),

	AMBIENTLIGHT = (1<<5),

	CAMERA = (1<<5),

};

uint8_t receptionFinished = 0;

uint8_t currentSlave = 0;

uint8_t currentSlaveSensor = 0;

uint8_t maxSlave = 8;

uint16_t slaves[8];

void slavesensors_setup() 

{

	// Empty array

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

	{

		slaves[i] = 0;

	}	

	// Configure sensors

	slaves[0] = SLAVE0_SENSORS;

	slaves[1] = SLAVE1_SENSORS;

	slaves[2] = SLAVE2_SENSORS;

	slaves[3] = SLAVE3_SENSORS;

	slaves[4] = SLAVE4_SENSORS;

	slaves[5] = SLAVE5_SENSORS;

	slaves[6] = SLAVE6_SENSORS;

	slaves[7] = SLAVE7_SENSORS;	

}

bool slavesensors_process() 

{

	// Periodic: Every Iteration

	// maybe we should do this in an ISR on byte received. only problem is that this could interrupt things,

	// but we only care about interruption during logging and such. don't log when parsing a message?

	receptionFinished = serparser_parse();

	// Finished reception of a message (one sensor data value). If not finished, send out command to get the next one

	if(receptionFinished == 2)

	{

		bool weFinishedTHeLastSlaveSensor = false; // ex.

		// if we finished the final reception for this slave, set gettingValues = false;

		if(currentSlave >= maxSlave && weFinishedTHeLastSlaveSensor)

		{

			currentSlave = 0;

			return false; // We're done for now!

		}

		else

		{

			// Request data from the next slave

			currentSlave++;

			// Need to check the next bit over to see if it has that...

			serial_sendCommand(currentSlave, 'a', ""); // send req for data

			return true; // Keep going...

		}

	}

	else 

	{

		return true; // Keep going...

	}

}		

/*

 * slavesensors.h

 *

 * Created: 11/27/2012 9:05:47 PM

 *  Author: ethanzonca

 */ 

#ifndef SLAVESENSORS_H_

#define SLAVESENSORS_H_

#include <stdbool.h>

void slavesensors_setup();

bool slavesensors_process();

#endif /* SLAVESENSORS_H_ */

#include <stdio.h>

#include <stdbool.h>

#include "lib/slavesensors.h"

	// Initialize libraries

	serial0_setup();

	serial1_setup();

	slavesensors_setup();

	logger_setup();

	afsk_setup();

	// Buffer for string operations

	char logbuf[32];

	const char* logBufPtr = logbuf;

	// Software timers	

	// If we are currently processing sensor data

	bool isProcessing = false;

	// Write CSV header to SD card

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

		// Periodic: Logging

		if(time_millis() - lastLog > LOGGER_RATE) {

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

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

			serial0_sendString(logBufPtr);

		// Periodic: APRS transmission

		if(time_millis() - lastAprsBroadcast > APRS_TRANSMIT_PERIOD) {

			// Start getting values for next transmission

			isProcessing = true;

		// keep calling processSensors until it is finished

		if(isProcessing) 

		{

			isProcessing = slavesensors_process();

		}

    <Compile Include="lib\slavesensors.c">

      <SubType>compile</SubType>

    </Compile>

    <Compile Include="lib\slavesensors.h">

      <SubType>compile</SubType>

    </Compile>