seniordesign-firmware Changeset - fb9fb20b39da

Changeset - fb9fb20b39da

Parent rev.

Child rev.

[Not reviewed]

default

0 8 0

ethanzonca@CL-ENS241-08.cedarville.edu - 12 years ago 2013-01-18 16:53:44
ethanzonca@CL-ENS241-08.cedarville.edu

Fixed issue where timeouts were not functional, number of discovered nodes now displayed on center LEDs.

8 files changed with 69 insertions and 64 deletions:

master/master/config.h

master/master/lib/boardtemp.c

master/master/lib/gps.c

master/master/lib/led.c

master/master/lib/led.h

master/master/lib/logger.c

master/master/lib/slavesensors.c

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

master/master/lib/boardtemp.c

➞

Show inline comments

 /*
  * sensors.c
+ *
  * Created: 11/19/2012 9:25:01 PM
  *  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"
 int8_t	boardTemp;	// Board Temperature (from i2c)
+int8_t	boardTemp = 255;	// Board Temperature (from i2c)
 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;
+}

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;
 /*
 volatile uint8_t charTest;
 ISR(USART1_RX_vect)
+{
 	serial0_sendChar(UDR1);
 }*/
 // 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;
 char convertBuf1[15];
 char convertBuf2[15];
 // 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
 				// First 2 bytes
 				//convertBuf1[0] = latitude[0];
 				//convertBuf1[1] = latitude[1];
 				//convertBuf1[2] = '\0';
 				//strncpy(convertBuf2, latitude, 7);
 				//convertBuf2[7] = '\0';
 				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

master/master/lib/led.c

➞

Show inline comments

 /*
  * Master Firmware: Status and Error LED Handler
+ *
  * 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 "led.h"
 // Configure port direction and initial state of LEDs
 void led_setup()
+{
 	for(int i=0; i<NUM_LEDS; i++)  {
 		*(ledList[i].direction) |= (1<<ledList[i].pin); // set pin to output
 		*(ledList[i].port) &= ~(1<<ledList[i].pin); // set pin low
+	}
+}
 // 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);
+}
 void led_toggle(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)
+{
 	led_off(LED_ERROR);
 	_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);
+}
 uint8_t ctr = 0;
 void led_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;
+}
@@ \ No newline at end of file @@

master/master/lib/led.h

➞

Show inline comments

 /*
  * Master Firmware: Status and Error LED Handler
+ *
  * Wireless Observational Modular Aerial Network
+ *
  * Ethan Zonca
  * Matthew Kanning
  * Kyle Ripperger
  * Matthew Kroening
+ *
  */
 #ifndef LED_H_
 #define LED_H_
 #include <avr/io.h>
 enum leds {
 	LED_ACT0 = 0,
 	LED_ACT1,
 	LED_ACT2,
 	LED_ACT3,
 	LED_POWER,
 	LED_STATUS,
 	LED_ERROR,
 	LED_SIDEBOARD,
 	LED_ACTIVITY,
 	LED_CYCLE,
 	LED_HEAT
 };
 typedef struct {uint8_t* direction; uint8_t* port; uint8_t pin;} led_t;
 // Match order of leds enum
 static led_t ledList[] = {
 	{&DDRA, &PORTA, PA1}, // ACT0
 	{&DDRA, &PORTA, PA2}, // ACT1
 	{&DDRA, &PORTA, PA3}, // ACT2
 	{&DDRA, &PORTA, PA4}, // ACT3
 //pcb:
 	{&DDRB, &PORTB, PB4}, // POWER
 	{&DDRB, &PORTB, PB3}, // STATUS
 	{&DDRB, &PORTB, PB2}, // ERROR
 //breadboard:
 //	{&DDRA, &PORTA, PA2}, // POWER
 //	{&DDRA, &PORTA, PA0}, // STATUS
 //	{&DDRA, &PORTA, PA1}, // 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_toggle(uint8_t led);
 void led_errorcode(uint8_t code);
 void led_spin();
 #endif /* LED_H_ */

master/master/lib/logger.c

➞

Show inline comments

 /*
  * Master Firmware: SD Card Data Logger
+ *
  * Wireless Observational Modular Aerial Network
+ *
  * Ethan Zonca
  * Matthew Kanning
  * Kyle Ripperger
  * Matthew Kroening
+ *
  */
 #include "../config.h"
 #include <util/delay.h>
 #include <string.h>
 #include <stdio.h>
 #include <avr/pgmspace.h>
 #include <avr/sleep.h>
 #include <avr/eeprom.h>
 #include <string.h>
 #include "sdcard/fat.h"
 #include "sdcard/fat_config.h"
 #include "sdcard/partition.h"
 #include "sdcard/sd_raw.h"
 #include "sdcard/sd_raw_config.h"
 #include "logger.h"
 #include "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!
 		#ifdef DEBUG_OUTPUT
 		serial0_sendString("SD> Error initializing.\r\n");
 		#endif
 		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)
+	{
 		#ifdef DEBUG_OUTPUT
 		serial0_sendString("SD> Error opening partition.\r\n");
 		#endif
 		// 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);
 		return;
+	}
 	// Open directory
 	fat_get_dir_entry_of_path(fs, "/", &directory);
 	dd = fat_open_dir(fs, &directory);
 	if(!dd)
+	{
 		// opening root directory failed
 		_delay_ms(10);
 		led_errorcode(ERROR_SD_FILE);
 		return;
+	}
 	// Create new log file
 	uint8_t logid = eeprom_read_byte(LOGGER_ID_EEPROM_ADDR);
 	char filename[48];
 	// we pre-increment logid here because it starts at 255, then wraps to 0
 	sprintf(filename, "data%d.csv",++logid);
 	// TODO: Catch errors here
 	if(fat_create_file(dd, filename, &directory) == 0) {
 		led_errorcode(ERROR_SD_FILE);
+	}
 	eeprom_update_byte(LOGGER_ID_EEPROM_ADDR, logid);
 	// Search for file in current directory and open it
 	fd = open_file_in_dir(fs, dd, filename);
 	if(!fd)
+	{
 		led_errorcode(ERROR_SD_FILE);
 		_delay_ms(10);
 		return;
+	}
 	// Seek to beginning of file
 	// TODO: Is this needed?
 	int32_t offset = 0;
 	if(!fat_seek_file(fd, &offset, FAT_SEEK_SET))
+	{
 		// Error seeking to file
 		led_errorcode(ERROR_SD_FILE);
 		_delay_ms(10);
 		fat_close_file(fd);
 		return;
+	}
 	// Write header information
 	logger_log(LOGGER_HEADERTEXT);
 	logger_log("\n-- BEGIN DATA --\n");
+}
 void logger_log(char *buffer)
+{
 	uint8_t len = strlen(buffer);
 	if(fat_write_file(fd, (uint8_t*) buffer, len) != len)
+	{
 		// Error writing to file
 		return;
+	}
+}
 void logger_closeLog()
+{
 	fat_close_file(fd);
 	fat_close_dir(dd);
 	fat_close(fs);
 	partition_close(partition);
+}
 // INTERNAL FUNCTIONS
 // Opens a file so it can be read/written
 struct fat_file_struct* open_file_in_dir(struct fat_fs_struct* fs, struct fat_dir_struct* dd, const char* name)

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()
+{
 	// 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;
+}
 #define DEBUG_NETWORKSCAN
 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;
 	#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
 	uint8_t nodeCount = 0;
 	// wait for OK
 	//todo
 	if(atOK == 0)
+	{
 		led_on(LED_STATUS);
 		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
 				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_NETWORKSCAN
+	#ifdef DEBUG_OUTPUT
 	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
 	// 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
 	for(int i=0; i<nodeCount; i++)
+	{
 		if(strcmp(slaveNames[i], XBEE_LOGDEST_NAME) == 0)
+		{
 			loggerIndex = i;
+		}
+	}
 	slavesensors_loggerdest();
 	serial0_ion();
+}
 void slavesensors_loggerdest()
+{
 	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;
+	}
+}
 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;
+}
 bool slavesensors_isrequesting()

master/master/master.c

➞

Show inline comments

 /*
  * 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/gps.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)
+{
 	led_on(LED_POWER);
 	// 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
 	#ifdef DEBUG_OUTPUT
 	serial0_sendString("\r\n---------------------------------\r\n");
 	serial0_sendString("HAB Controller 1.0 - Initialized!\r\n");
 	serial0_sendString("---------------------------------\r\n");
 	#endif
 	serial0_sendString("\r\nHello.\r\n\r\n");
 	slavesensors_network_scan(); // This can take a little while
 	// 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();
+			led_spin();
 			if(!afsk_busy())
 				serial1_ion();
 			lastLedCycle = time_millis();
+		}
 		// Periodic: Logging
 		if(time_millis() - lastLog > LOGGER_RATE)
+		{
 			led_on(LED_CYCLE);
 			heater_regulateTemp();
 			// Print out GPS debug
 			//snprintf(debugBuf, 128, "GPS> time: %s lat: %s lon: %s speed: %s hdop: %s course: %s\r\n",
 			//get_timestamp(),get_latitude(),get_longitude(),get_speedKnots(),get_hdop(), get_course());
 			//serial0_sendString(debugBuf);
 			// Turn on sideboard LED if we have a fix
 			if(strcmp("99.99", get_hdop()) == 0) {
 				led_off(LED_SIDEBOARD);
+			}
 			else {
 				led_on(LED_SIDEBOARD);
+			}
 			sensors_readBoardTemp(); // i2c read, 400k
 			snprintf(logbuf, 128, "%lu,%d,%u,%s,%s,%s,%s,%s\r\n", time_millis(), sensors_getBoardTemp(),get_timestamp(),get_latitude(),get_longitude(),get_speedKnots(),get_hdop(), get_course());
 			logger_log(logbuf);
 			// Print out logger debug
 			#ifdef DEBUG_OUTPUT
 			serial0_sendString("LOG> ");
 			serial0_sendString(logbuf);
 			#endif
 			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();
+    }
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)