seniordesign-firmware Changeset - e3153d5a767c

Changeset - e3153d5a767c

Parent rev.

Child rev.

[Not reviewed]

default

0 6 0

ethanzonca@CL-ENS241-08.cedarville.edu - 13 years ago 2013-01-21 20:59:15
ethanzonca@CL-ENS241-08.cedarville.edu

Implemented new serial protocol and slave sensor data storage technique, appears to be functional.

6 files changed with 74 insertions and 87 deletions:

master/master/config.h

master/master/lib/gps.c

master/master/lib/sensordata.c

master/master/lib/sensordata.h

master/master/lib/serparser.c

master/master/lib/slavesensors.c

0 comments (0 inline, 0 general)

master/master/config.h

➞

Show inline comments

 /*
  * 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)
 // --------------------------------------------------------------------------
 // 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
 #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_ */
@@ \ No newline at end of file @@

master/master/lib/gps.c

➞

Show inline comments

 /*
 * gpsMKa.c
+*
 * 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;
 //variables to store data from transmission
 //least significant digit is stored at location 0 of arrays
 char tramsmissionType[7];
 char timestamp[12];	//hhmmss.ss
 char* get_timestamp() {
 	return timestamp;
+}
 char latitude[14];	//lllll.lla
 char* get_latitude() {
 	return latitude;
+}
 char longitude[14];	//yyyyy.yyb
 char* get_longitude() {
 	return longitude;
+}
 char quality;		//quality for GGA and validity for RMC
 char numSatellites[4];
 char* getNumSatelites() {
 	return numSatellites;
+}
 char hdop[6];		//xx.x
 char* get_hdop() {
 	return hdop;
+}
 char altitude[10];	//xxxxxx.x
 char wgs84Height[8];	//sxxx.x
 char lastUpdated[8];	//blank - included for testing
 char stationID[8];	//blank - included for testing
 char checksum[3];	//xx
 char knots[8];		//xxx.xx
 char* get_speedKnots() {
 	return knots;
+}
 char course[8];		//xxx.x
 char* get_course() {
 	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,
 	GGA_HDOP,
 	GGA_ALTITUDE,
 	GGA_WGS84,
 	GGA_LAST_UPDATE,
 	GGA_STATION_ID,
 	//RMC data fields
 	RMC_TIME,
 	RMC_VALIDITY,
 	RMC_LATITUDE,
 	RMC_LONGITUDE,
 	RMC_KNOTS,
 	RMC_COURSE,
 	RMC_DATE,
 	RMC_MAG_VARIATION,
 }decodeState;
 char debugBuff[128];
 ISR(USART1_RX_vect)
+{
 	nmeaBuffer[nmeaBufferDataPosition % NMEABUFFER_SIZE] = UDR1;
 	nmeaBufferDataPosition = (nmeaBufferDataPosition + 1) % NMEABUFFER_SIZE;
 	//serial0_sendChar(UDR1);
 	//snprintf(debugBuff, 32, "GPS: bdp: %d, bpp: %d decodestate: %u \r\n", nmeaBufferDataPosition, nmeaBufferParsePosition, decodeState);
 	//serial0_sendString((debugBuff));
+}
 // Could inline if program space available
 static void setParserState(uint8_t state)
+{
 	decodeState = state;
 	// If resetting, clear vars
 	if(state == INITIALIZE)
+	{
 		calculatedChecksum = 0;
+	}
 	// Every time we change state, we have parsed a byte
 	nmeaBufferParsePosition = (nmeaBufferParsePosition + 1) % NMEABUFFER_SIZE;
+}
 //// MKa GPS transmission parser START
 void parse_gps_transmission(void){
 	// Pull byte off of the buffer
 	char byte;
 	while(nmeaBufferDataPosition != nmeaBufferParsePosition) {
 	led_on(LED_ACTIVITY);
 		byte = nmeaBuffer[nmeaBufferParsePosition];
 		//snprintf(debugBuff, 64, "GPSParse: byte [%c] decodestate: %u bp: %u pp: %u\r\n",  byte, decodeState, nmeaBufferDataPosition, nmeaBufferParsePosition);
 		//serial0_sendString((debugBuff));
 		if(decodeState == INITIALIZE) //start of transmission sentence
+		{
 			if(byte == '$') {
 				#ifdef DEBUG_NMEA
 				serial0_sendString("found $\r\n");
 				#endif
 				setParserState(GET_TYPE);
 				numBytes = 0; //prep for next phases
 				skipBytes = 0;
 				calculatedChecksum = 0;
+			}
 			else {
 				setParserState(INITIALIZE);
+			}
+		}
 		//parse transmission type
 		else if (decodeState == GET_TYPE)
+		{
 			tramsmissionType[numBytes] = byte;
 			numBytes++;
 			#ifdef DEBUG_NMEA
 			serial0_sendString("stored a type byte\r\n");
 			#endif
 			if(byte == ',') //end of this data type
+			{
 				tramsmissionType[5] = 0x00;
 				if (tramsmissionType[2] == 'G' &&
 				tramsmissionType[3] == 'G' &&
 				tramsmissionType[4] == 'A')
+				{
 					setParserState(GGA_TIME);
 					numBytes = 0;
+				}
 				else if (tramsmissionType[2] == 'R' &&
 				tramsmissionType[3] == 'M' &&
 				tramsmissionType[4] == 'C')
+				{
 					setParserState(RMC_TIME);
 					numBytes = 0;
+				}
 				else //this is an invalid transmission type
+				{
 					setParserState(INITIALIZE);
+				}
+			}
 			else {
 				// continue
 				setParserState(GET_TYPE);
+			}
+		}
 		///parses GGA transmissions START
 		/// $--GGA,hhmmss.ss,llll.ll,a,yyyyy.yy,a,x,xx,x.x,x.x,M,x.x,M,x.x,xxxx*xx
 		//timestamp
 		else if (decodeState == GGA_TIME)
+		{
 			if (byte == ',') //end of this data type
+			{
 				timestamp[4] = 0x00; // Cut off at 4 (no seconds) for APRS
 				setParserState(GGA_LATITUDE);
 				skipBytes = 0; //prep for next phase of parse
 				numBytes = 0;
+			}
 			else //store data
+			{
 				#ifdef DEBUG_NMEA
 				serial0_sendString("found GGA time byte\r\n");
 				#endif
 				setParserState(GGA_TIME);
 				timestamp[numBytes] = byte; //byte; //adjust number of bytes to fit array
 				numBytes++;
+			}
+		}
 		//latitude
 		else if (decodeState == GGA_LATITUDE)
+		{
 			if (byte == ',' && skipBytes == 0) //discard this byte
+			{
 				#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++;
 				setParserState(GGA_LATITUDE);
+			}
+		}
 		//longitude
 		else if (decodeState == GGA_LONGITUDE)
+		{
 			if (byte == ',' && skipBytes == 0) //discard this byte
+			{
 				#ifdef DEBUG_NMEA
 				serial0_sendString("found long skip byte\r\n");
 				#endif
 				skipBytes = 1;
 				setParserState(GGA_LONGITUDE);
+			}
 			else if (byte == ',') //end of this data type
+			{
 				longitude[8] = 0x00;
 				setParserState(GGA_QUALITY);
 				numBytes = 0; //prep for next phase of parse
 				skipBytes = 0;
+			}
 			else //store data
+			{
 				#ifdef DEBUG_NMEA
 				serial0_sendString("found long byte\r\n");
 				#endif
 				longitude[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_LONGITUDE);
+			}
+		}
 		//GGA quality
 		else if (decodeState == GGA_QUALITY)
+		{
 			if (byte == ',') //end of this data type
+			{
 				setParserState(GGA_SATELLITES);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				#ifdef DEBUG_NMEA
 				serial0_sendString("found quality byte\r\n");
 				#endif
 				quality = byte; //maybe reset if invalid data ??
 				setParserState(GGA_QUALITY);
+			}
+		}
 		//number of satellites
 		else if (decodeState == GGA_SATELLITES)
+		{
 			if (byte == ',') //end of this data type
+			{
 				numSatellites[numBytes] = 0x00;
 				setParserState(GGA_HDOP);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				numSatellites[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_SATELLITES);
+			}
+		}
 		//HDOP
 		else if (decodeState == GGA_HDOP)
+		{
 			if (byte == ',' ) //end of this data type
+			{
 				hdop[numBytes] = 0x00;
 				setParserState(GGA_ALTITUDE);
 				numBytes = 0; //prep for next phase of parse
 				skipBytes = 0;
+			}
 			else //store data
+			{
 				hdop[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_HDOP);
+			}
+		}
 		//altitude
 		else if (decodeState == GGA_ALTITUDE)
+		{
 			if (byte == ',' && skipBytes == 0) //discard this byte
+			{
 				skipBytes = 1;
 				setParserState(GGA_ALTITUDE);
+			}
 			else if(byte == ',') //end of this data type
+			{
 				altitude[numBytes] = 0x00;
 				setParserState(GGA_WGS84);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				altitude[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_ALTITUDE);
+			}
+		}
 		//WGS84 Height
 		else if (decodeState == GGA_WGS84)
+		{
 			if (byte == ',' && skipBytes == 0) //discard this byte
+			{
 				skipBytes = 1;
 				setParserState(GGA_WGS84);
+			}
 			else if(byte == ',') //end of this data type
+			{
 				wgs84Height[numBytes] = 0x00;
 				setParserState(GGA_LAST_UPDATE);
 				skipBytes = 0; //prep for next phase of parse
 				numBytes = 0;
+			}
 			else //store data
+			{
 				wgs84Height[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_WGS84);
+			}
+		}
 		//last GGA DGPS update
 		else if (decodeState == GGA_LAST_UPDATE)
+		{
 			if (byte == ',') //end of this data type
+			{
 				lastUpdated[numBytes] = 0x00;
 				setParserState(GGA_STATION_ID);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data - this should be blank
+			{
 				lastUpdated[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_LAST_UPDATE);
+			}
+		}
 		//GGA DGPS station ID
 		else if (decodeState == GGA_STATION_ID)
+		{
 			if (byte == ',' || byte == '*') //end of this data type
+			{
 				stationID[numBytes] = 0x00;
 				setParserState(GPS_CHECKSUM);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data - this should be blank
+			{
 				stationID[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(GGA_STATION_ID);
+			}
+		}
 		///parses GGA transmissions END
 		/// $GPRMC,hhmmss.ss,A,llll.ll,a,yyyyy.yy,a,x.x,x.x,ddmmyy,x.x,a*hh
 		///parses RMC transmissions
 		//time
 		// emz: commented setter, GMC time better?
 		else if(decodeState == RMC_TIME)
+		{
 			if (byte == ',') //end of this data type
+			{
 				//timestamp[numBytes] = 0x00;
 				setParserState(RMC_VALIDITY);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				#ifdef DEBUG_NMEA
 				serial0_sendString("found time byte\r\n");
 				#endif
 				//timestamp[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(RMC_TIME);
+			}
+		}
 		//validity
 		// not needed? dupe gga
 		else if(decodeState == RMC_VALIDITY)
+		{
 			if (byte == ',') //end of this data type
+			{
 				setParserState(RMC_LATITUDE);
 				skipBytes = 0; //prep for next phase of parse
 				numBytes = 0;
+			}
 			else //store data
+			{
 				#ifdef DEBUG_NMEA
 				serial0_sendString("found valid byte\r\n");
 				#endif
 				//quality = byte;
 				numBytes++;
 				setParserState(RMC_VALIDITY);
+			}
+		}
 		//latitude RMC (we don't need this, commented out setter)
 		else if(decodeState == RMC_LATITUDE)
+		{
 			if (byte == ',' && skipBytes == 0) //discard this byte
+			{
 				#ifdef DEBUG_NMEA
 				serial0_sendString("found lat skip byte\r\n");
 				#endif
 				skipBytes = 1;
 				setParserState(RMC_LATITUDE);
+			}
 			else if (byte == ',') //end of this data type
+			{
 				setParserState(RMC_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++;
 				setParserState(RMC_LATITUDE);
+			}
+		}
 		//longitude RMC (we don't need this, commented out setter)
 		else if(decodeState == RMC_LONGITUDE)
+		{
 			if (byte == ',' && skipBytes == 0) //discard this byte
+			{
 				#ifdef DEBUG_NMEA
 				serial0_sendString("found long byte\r\n");
 				#endif
 				skipBytes = 1;
 				setParserState(RMC_LONGITUDE);
+			}
 			else if (byte == ',') //end of this data type
+			{
 				setParserState(RMC_KNOTS);
 				skipBytes = 0;
 				numBytes = 0;
+			}
 			else //store data
+			{
 				#ifdef DEBUG_NMEA
 				serial0_sendString("found long byte\r\n");
 				#endif
 				//longitude[numBytes]= byte; //adjust number of bytes to fit array
 				numBytes++;
 				setParserState(RMC_LONGITUDE);
+			}
+		}
 		//knots
 		else if(decodeState == RMC_KNOTS)
+		{
 			if (byte == ',') //end of this data type
+			{
 				knots[numBytes] = 0x00;
 				setParserState(RMC_COURSE);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				setParserState(RMC_KNOTS);
 				knots[numBytes]= byte; //adjust number of bytes to fit array
 				numBytes++;
+			}
+		}
 		//course
 		else if(decodeState == RMC_COURSE)
+		{
 			if (byte == ',') //end of this data type
+			{
 				course[numBytes] = 0x00;
 				setParserState(RMC_DATE);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				setParserState(RMC_COURSE);
 				course[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
+			}
+		}
 		//date
 		else if(decodeState == RMC_DATE)
+		{
 			if (byte == ',') //end of this data type
+			{
 				// Cut it off at day of month. Also has month and year if we ever need it.
 				dayofmonth[2] = 0x00;
 				setParserState(RMC_MAG_VARIATION);
 				skipBytes = 0; //prep for next phase of parse
 				numBytes = 0;
+			}
 			else //store data
+			{
 				setParserState(RMC_DATE);
 				dayofmonth[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
+			}
+		}
 		//magnetic variation
 		else if(decodeState == RMC_MAG_VARIATION)
+		{
 			if (byte == '*') //end of this data type
+			{
 				variation[numBytes] = 0x00;
 				setParserState(GPS_CHECKSUM);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				setParserState(RMC_MAG_VARIATION);
 				variation[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
+			}
+		}
 		///parses RMC transmissions END
 		//checksum
 		else if (decodeState == GPS_CHECKSUM)
+		{
 			if (numBytes == 2) //end of data - terminating character ??
+			{
 				//checksum calculator for testing http://www.hhhh.org/wiml/proj/nmeaxor.html
 				//TODO: must determine what to do with correct and incorrect messages
 				receivedChecksum = checksum[0] + (checksum[1]*16);	//convert bytes to int
 				if(calculatedChecksum==receivedChecksum)
+				{
+				}
 				else
+				{
+				}
 				#ifdef DEBUG_NMEA
 				serial0_sendString("OMG GOT TO CHECKSUM!\r\n");
 				#endif
+				#endif
 				serial0_sendString((debugBuff));
 				setParserState(INITIALIZE);
 				numBytes = 0; //prep for next phase of parse
+			}
 			else //store data
+			{
 				setParserState(GPS_CHECKSUM);
 				checksum[numBytes] = byte; //adjust number of bytes to fit array
 				numBytes++;
+			}
+		}
 		else {
 			setParserState(INITIALIZE);
+		}
 		if (decodeState!=GPS_CHECKSUM && decodeState!=INITIALIZE)	//want bytes between '$' and '*'
+		{
 			//input byte into running checksum
 			XORbyteWithChecksum(byte);
+		}
 		led_off(LED_ACTIVITY);
+	}
+}
 /// MKa GPS transmission parser END
 void XORbyteWithChecksum(uint8_t byte){
 	calculatedChecksum ^= (int)byte; //this may need to be re-coded
+}

master/master/lib/sensordata.c

➞

Show inline comments

 /*
  * Master Firmware: Sensor Data
+ *
  * Wireless Observational Modular Aerial Network
+ *
  * Ethan Zonca
  * Matthew Kanning
  * Kyle Ripperger
  * Matthew Kroening
+ *
  */
 #include "../config.h"
 #include "sensordata.h"
 int16_t boardTemps[MAX_SLAVES];
 uint16_t variousSensors[MAX_SLAVES * (MAX_SLAVE_SENSORS - 1)];
 int16_t slaves[MAX_NUM_SLAVES][MAX_NUM_SENSORS];
 void sensordata_setup()
+{
 	for(int i=0; i<MAX_SLAVES; i++)
+	{
 		boardTemps[i] = 0;
 	for(int i=0; i<MAX_NUM_SLAVES; i++) {
 		for(int j=0; j<MAX_NUM_SLAVES; j++) {
 			slaves[i][j] = -32768; // minimum value of 16 bit integer
+		}
+	}
+}
-void sensordata_set(uint8_t type, uint16_t value)
+void sensordata_set(uint8_t nodeID, uint8_t type, uint16_t value)
+{
 	variousSensors[type] = value;
+}
 uint16_t sensordata_get(uint8_t type)
+{
 	return variousSensors[type];
 	if(nodeID < MAX_NUM_SLAVES) {
 		slaves[nodeID][type] = value;
+	}
+}
-void sensordata_setBoardTemp(uint8_t slaveID, int16_t value)
+uint16_t sensordata_get(uint8_t nodeID, uint8_t type)
+{
 	boardTemps[slaveID] = value;
 	// Avoid reading out of bad places!
 	if(nodeID < MAX_NUM_SLAVES) {
 		return slaves[nodeID][type];
+	}
 	else {
 		return 0;
+	}
+}
 int16_t sensordata_getBoardTemp(uint8_t slaveID)
+{
 	return boardTemps[slaveID];
+}
@@ \ No newline at end of file @@

master/master/lib/sensordata.h

➞

Show inline comments

 /*
  * Master Firmware: Sensor Data
+ *
  * Wireless Observational Modular Aerial Network
+ *
  * Ethan Zonca
  * Matthew Kanning
  * Kyle Ripperger
  * Matthew Kroening
+ *
  */
 #ifndef SENSORDATA_H_
 #define SENSORDATA_H_
 #include "slavesensors.h"
 void sensordata_setup();
 void sensordata_set(uint8_t type, uint16_t value);
 uint16_t sensordata_get(uint8_t type);
 void sensordata_set(uint8_t nodeID, uint8_t type, uint16_t value);
 uint16_t sensordata_get(uint8_t nodeID, uint8_t type);
 void sensordata_setBoardTemp(uint8_t slaveID, int16_t value);
 int16_t sensordata_getBoardTemp(uint8_t slaveID);
 #endif /* SENSORDATA_H_ */
@@ \ No newline at end of file @@

master/master/lib/serparser.c

➞

Show inline comments

 /*
  * Master Firmware: Serial Parser
+ *
  * Wireless Observational Modular Aerial Network
+ *
  * Ethan Zonca
  * Matthew Kanning
  * Kyle Ripperger
  * Matthew Kroening
+ *
  */
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include "../config.h"
 #include "serial.h"
 #include "serparser.h"
 #include "led.h"
 // Circular buffer for incoming data
 uint8_t buffer[BUFFER_SIZE];
 // Location of parser in the buffer
 uint8_t bufferParsePosition = 0;
 // Location of receive byte interrupt in the buffer
 volatile uint16_t bufferDataPosition = 0;
 // Parser state
 uint8_t parserState = STATE_RESET;
 uint8_t lastParserState = STATE_RESET;
 // Length of current payload data (and checksum)
 uint8_t payloadLength = 0;
 // Data and checksum of most recent transmission
 char receivedPayload[MAX_PAYLOAD_LEN];
 // Payload type ID of the sensor of most recent transmission
 char receivedPayloadType = 0;
 // Checksum to be calculated and then compared to the received checksum
 char checksumCalc = 0;
 // Accessors
 uint8_t getPayloadLength()
+{
 	return payloadLength;
+}
 uint8_t* getPayload()
+{
 	return receivedPayload;
+}
 uint8_t getPayloadType() {
 	return receivedPayloadType;
+}
 // Could inline if program space available
 static void setParserState(uint8_t state)
+{
 	lastParserState = parserState;
 	parserState = state;
 	// If resetting, clear vars
 	if(state == STATE_RESET)
+	{
 		payloadLength = 0;
 		checksumCalc = 0;
+	}
 	// Every time we change state, we have parsed a byte
 	bufferParsePosition = (bufferParsePosition + 1) % BUFFER_SIZE;
+}
 // Receive data on USART
 char debugBuff[16];
 ISR(USART0_RX_vect)
+{
 	buffer[bufferDataPosition % BUFFER_SIZE] = UDR0;
 	bufferDataPosition = (bufferDataPosition + 1) % BUFFER_SIZE;
 	//sprintf(debugBuff, "bdp: %d, bpp: %d \r\n", bufferDataPosition, bufferParsePosition);
 	//serial0_sendString((debugBuff));
+}
 #define DEBUG
+//#define DEBUG
 // Parse data from circular buffer
 int serparser_parse(void)
+{
 	char byte;
 	// Process first command (if any) on the circular buffer
 	while(bufferDataPosition != bufferParsePosition)
+	{
 		byte = buffer[bufferParsePosition];
 		// Reset
 		if(parserState == STATE_RESET)
+		{
 			if(byte == '[') // Start of frame; keep parsing
+			{
 				#ifdef DEBUG
 				serial0_sendString("start\r\n");
 				#endif
 				setParserState(STATE_GETDATATYPE);
+			}
 			else // Not start of frame, reset
+			{
 				#ifdef DEBUG
 				serial0_sendString("invalid\r\n");
 				#endif
 				setParserState(STATE_RESET);
 				return PARSERESULT_NODATA; // no valid start bit; better luck next time. run the function the next time around the main loop.
+			}
+		}
 		// Get payload type ID
 		else if(parserState == STATE_GETDATATYPE)
+		{
 			#ifdef DEBUG
 			serial0_sendString("type\r\n");
 			#endif
 			receivedPayloadType = byte; // Store the type of data receiving
+			receivedPayloadType = byte - 0x30; // Store the type of data receiving
 			checksumCalc += byte;
 			setParserState(STATE_GETDATA);
+		}
 		// Get payload data
 		else if(parserState == STATE_GETDATA)
+		{
 			if (byte == ']') // End of frame
+			{
 				#ifdef DEBUG
 				serial0_sendString("eof\r\n");
 				sprintf(debugBuff, "%d B, sum=%d\r\n", payloadLength, checksumCalc);
 				serial0_sendString((debugBuff));
 				#endif
 				receivedPayload[payloadLength] = 0; // null-terminate string for atoi
 				setParserState(STATE_GETCHECKSUM);
 				// Checksum is now after the close bracket to solve bug FS#29
+			}
 			else // Still receiving data
+			{
 				#ifdef DEBUG
 				serial0_sendString("data\r\n");
 				#endif
 				receivedPayload[payloadLength] = byte;
 				payloadLength++;
 				checksumCalc += byte;
 				// Data buffer overrun protection
 				if(payloadLength > MAX_PAYLOAD_LEN) {
 					#ifdef DEBUG
 					serial0_sendString("ovf\r\n");
 					#endif
 					setParserState(STATE_RESET);
 					return PARSERESULT_FAIL;
+				}
 				else {
 					// Set state. MUST call even though state is maintained to update parse position
 					setParserState(STATE_GETDATA);
 					return PARSERESULT_STILLPARSING;
+				}
+			}
+		}
 		else if(STATE_GETCHECKSUM)
+		{
 			// TODO: Compare checksums
 			if(byte == checksumCalc) {
 				#ifdef DEBUG
 				serial0_sendString("check\r\n");
 				#endif
 				setParserState(STATE_RESET);
 				return PARSERESULT_PARSEOK;
+			}
 			else {
 				#ifdef DEBUG
 				serial0_sendString("bcheck\r\n");
 				#endif
 				setParserState(STATE_RESET);
 				return PARSERESULT_FAIL;
 				return PARSERESULT_PARSEOK;
 				// !!!!!!!!!!!!!DEBUGGGGG ignore checksum ///// return PARSERESULT_FAIL;
+			}
 			/*
 			if(bufferParsePosition == bufferDataPosition)
+			{
 				// We are at the end of the line. No more data to parse.
 				setParserState(STATE_RESET);
 				return PARSERESULT_PARSEOK;
+			}
 			else
+			{
 				setParserState(STATE_RESET);
 				// we could choose to keep parsing now, or parse the next message next loop around (better idea).
 				// return now so we hit it the next time around
 				return PARSERESULT_PARSEOK;
+			}
 			*/
+		}
+	}
 	return PARSERESULT_NODATA;
+}
@@ \ No newline at end of file @@

master/master/lib/slavesensors.c

➞

Show inline comments

 /*
  * 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 "looptime.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()
+{
+}
 #define DEBUG_NETWORKSCAN
 char* bufPtr = 0x00;
 char debugBuf[64];
 char slaveAddressLow[6][9];
 char slaveAddressHigh[6][9];
 char slaveAddressLow[MAX_NUM_SLAVES][9];
 char slaveAddressHigh[MAX_NUM_SLAVES][9];
 uint8_t loggerIndex = 255;
 uint8_t nodeCount = 0;
 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();
 	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
 	char slaveNames[MAX_NUM_SLAVES][16]; // Hold 16-char addresses of max MAX_NUM_SLAVES nodes, local so the memory can be reused
 	// wait for OK
 	//todo
 	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 > 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) {
 				strcpy(nameString, bufPtr);
 				strcpy(slaveNames[nodeCount], bufPtr);
+			}
 			// 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 newlinem after one chunk
+				// 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\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_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);
 	xbeeIsOk(); // wait for OK
+}
 // Enter AT mode. Leaves "OK" on the buffer.
 int slavesensors_enterAT()
+{
 	// Delay guard time
 	_delay_ms(1);
 	// Enter AT mode
 	serial0_sendChar('+'); // Enter AT mode
 	serial0_sendChar('+');
 	serial0_sendChar('+');
 	// Wait 1ms until we get "OK"
 	int atStart = time_millis();
 	while(!serial0_hasChar()) {
 		if(time_millis() - atStart > 500) {
 			led_errorcode(ERROR_XBEETIMEOUT);
 			wdt_reset();
 			return 1;
+		}
 	};
 	return xbeeIsOk();
+}
 int xbeeIsOk()
+{
 	char* tmppntr = serial0_readLine();
 	if(strcmp(tmppntr, "OK") == 0)
+	{
 		return 0;
+	}
 	else
+	{
 		led_errorcode(ERROR_NOXBEE);
 		return 1;
+	}
+}
 bool slavesensors_isrequesting()
+{
 	return requesting;
+}
 void slavesensors_startprocess()
+{
 	requesting = true;
 	slavesensors_request();
+}
 // TODO: inline. static.
 void slavesensors_request()
+{
 	//slavesensors_selectnode(currentSlave);
 	serial_sendCommand("@"); // Request data!
+}
-int numValues = 0; // number of values that the slave is about to send (testing)
+int 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)
+	{
 		// 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);
 		// Store data in structure
 		//sensordata_set(slaves[currentSlave][currentSlaveSensor], parsedVal);
 		// If we finished all sensors for all slaves
 		if(currentSlave >= nodeCount && currentSlaveSensor >= numValues)
+		{
 		// Special case for slave telling us how many things we're about to get
 		if(type + 0x30 == '@') {
 			serial0_sendString("Got an awesome count!\r\n");
 			serial0_sendChar(parsedVal + 0x30);
 			serial0_sendString("\r\n");
 			numReadingsToExpect = parsedVal;
 			currentSlave = 0;
 			currentSlaveSensor = 0;
-			requesting = false;
+			requesting = true;
+		}
 		// If we finished up one slave, go to the next
 		else if(currentSlaveSensor >= numValues)
+		{
 			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();
 		else {
 			// Store data in structure
 			sensordata_set(currentSlave,type,parsedVal);
 			serial0_sendString("Stored some sexy data!\r\n");
 			// If we finished all sensors for all slaves
 			if(currentSlave >= nodeCount && currentSlaveSensor >= numReadingsToExpect)
+			{
 				currentSlave = 0;
 				currentSlaveSensor = 0;
 				requesting = false;
+			}
 			// If we finished up one slave, go to the next
 			else if(currentSlaveSensor >= (numReadingsToExpect-1))
+			{
 				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();	 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;
+	}
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)