seniordesign-firmware Changeset - 0e02d91dac04

Changeset - 0e02d91dac04

Parent rev.

Child rev.

[Not reviewed]

default

0 6 0

ethanzonca@CL-ENS241-08.cedarville.edu - 12 years ago 2013-02-21 16:58:34
ethanzonca@CL-ENS241-08.cedarville.edu

Fixed compiler warnings

6 files changed with 10 insertions and 9 deletions:

master/master/lib/gps.c

master/master/lib/led.h

master/master/lib/logger.c

master/master/lib/sdcard/sd_raw.c

master/master/lib/slavesensors.c

master/master/master.c

0 comments (0 inline, 0 general)

master/master/lib/gps.c

➞

Show inline comments

 /*
  * Master Firmware: NMEA Parser
+ *
  * Wireless Observational Modular Aerial Network
+ *
  * Ethan Zonca
  * Matthew Kanning
  * Kyle Ripperger
  * Matthew Kroening
+ *
  */
 #include <stdbool.h>
 #include <string.h>
 #include <stdio.h>
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include "gps.h"
 #include "serial.h"
 #include "../config.h"
 #include "led.h"
 #include "logger.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 latitudeTmp[8];
 char* get_latitudeTrimmed()
+{
 	strncpy(latitudeTmp, &latitude[0], 7);
 	latitudeTmp[7] = 0x00;
 	return latitudeTmp;
+}
 char* get_latitudeLSBs()
+{
 	strncpy(latitudeTmp, &latitude[7], 3);
 	latitudeTmp[3] = 0x00;
 	return latitudeTmp;
+}
 char longitude[14];	//yyyyy.yyb
 char longitudeTmp[9];
 char* get_longitudeTrimmed()
+{
 	strncpy(longitudeTmp, &longitude[0], 8);
 	longitudeTmp[8] = 0x00;
 	return longitudeTmp;
+}
 char* get_longitudeLSBs()
+{
 	strncpy(longitudeTmp, &longitude[8], 3);
 	longitudeTmp[3] = 0x00;
 	return longitudeTmp;
+}
 char quality;		//quality for GGA and validity for RMC
 char numSatellites[4];
 char* get_sv()
+{
 	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()

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,
 	LED_BUZZ,
 };
 typedef struct {uint8_t* direction; uint8_t* port; uint8_t pin;} led_t;
+typedef struct {volatile uint8_t* direction; volatile 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
 	{&DDRB, &PORTB, PB4}, // POWER
 	{&DDRB, &PORTB, PB3}, // STATUS
 	{&DDRB, &PORTB, PB2}, // ERROR
 	{&DDRD, &PORTD, PD6}, // SIDEBOARD
 	{&DDRD, &PORTD, PD5}, // ACTIVITY
 	{&DDRD, &PORTD, PD4}, // CYCLE
 	{&DDRA, &PORTA, PA6}, // HEAT
 	{&DDRA, &PORTA, PA7}, // BUZZER
 };
 #define NUM_LEDS 12
 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();
 void led_alert();
 #endif /* LED_H_ */

master/master/lib/logger.c

➞

Show inline comments

@@ @@ -18,194 +18,194 @@ @@
 #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 "serial.h"
 #include "logger.h"
 #include "led.h"
 #include "looptime.h"
 #define MAX_ERRNO 8
 // Label lookup table
 // Make sure there are never more labels than there are MAX_NUM_SENSORS!
 const char err_0[] PROGMEM = "slave timeout";
 const char err_1[] PROGMEM = "initializing SD card failed";
 const char err_2[] PROGMEM = "opening SD partition failed";
 const char err_3[] PROGMEM = "opening SD file failed";
 const char err_4[] PROGMEM = "XBee timeout";
 const char err_5[] PROGMEM = "FATAL UNHANDLED ERROR";
 const char err_6[] PROGMEM = "enter AT mode failed";
 const char err_7[] PROGMEM = "exit AT mode failed";
 const char err_8[] PROGMEM = "infotext";
 const char *const errorMessageLookup[] PROGMEM =
+{
 	err_0,
 	err_1,
 	err_2,
 	err_3,
 	err_4,
 	err_5,
 	err_6,
 	err_7,
 	err_8,
 };
 struct partition_struct* partition;
 struct fat_fs_struct* fs;
 struct fat_dir_struct* dd;
 struct fat_file_struct* fd_datalog;
 struct fat_file_struct* fd_errorlog;
 void logger_setup()
+{
 	if(!sd_raw_init())
+	{
 		error_log(ERROR_SD_INIT, true);
 		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)
+	{
 		// Error opening partition. MBR might be screwed up.
 		error_log(ERROR_SD_PARTITION, true);
 		return;
+	}
 	// Open FAT filesystem
 	fs = fat_open(partition);
 	if(!fs)
+	{
 		// opening filesystem failed
 		error_log(ERROR_SD_PARTITION, true);
 		return;
+	}
 	// Open root directory
 	struct fat_dir_entry_struct rootDirEntry;
 	fat_get_dir_entry_of_path(fs, "/", &rootDirEntry);
 	dd = fat_open_dir(fs, &rootDirEntry);
 	if(!dd)
+	{
 		// opening root directory failed
 		_delay_ms(10);
 		error_log(ERROR_SD_FILE, true);
 		return;
+	}
 	// we pre-increment logid here because it starts at 255, then wraps to 0
 	uint8_t logid = eeprom_read_byte(LOGGER_ID_EEPROM_ADDR) + 1;
 	eeprom_update_byte(LOGGER_ID_EEPROM_ADDR, logid);
 	uint8_t logid = eeprom_read_byte((uint8_t*)LOGGER_ID_EEPROM_ADDR) + 1;
 	eeprom_update_byte((uint8_t*)LOGGER_ID_EEPROM_ADDR, logid);
 	int32_t errorOffset = 0;
 	char errorFilename[17];
 	// Form filename
 	snprintf(errorFilename, 17, "run%derror.csv",logid);
 	struct fat_dir_entry_struct errorDirEntry;
 	if(fat_create_file(dd, errorFilename, &errorDirEntry) == 0)
+	{
 		serial0_sendString("Error create errorlog\r\n");
 		error_log(ERROR_SD_FILE, true);
+	}
 	// Search for file in current directory and open it
 	fd_errorlog = open_file_in_dir(fs, dd, errorFilename);
 	if(!fd_errorlog)
+	{
 		serial0_sendString("Error open errorlog!\r\n");
 		error_log(ERROR_SD_FILE, true);
 		return;
+	}
 	errorOffset=0;
 	if(!fat_seek_file(fd_errorlog, &errorOffset, FAT_SEEK_SET))
+	{
 		// Error seeking to file
 		serial0_sendString("Error seek errorlog!\r\n");
 		error_log(ERROR_SD_FILE, true);
 		fat_close_file(fd_errorlog);
 		return;
+	}
 	int32_t dataOffset = 0;
 	char dataFilename[17];
 	// Form filename
 	snprintf(dataFilename, 17, "run%ddata.csv",logid);
 	struct fat_dir_entry_struct dataDirEntry;
 	// Create new data log file
 	if(fat_create_file(dd, dataFilename, &dataDirEntry) == 0)
+	{
 		serial0_sendString("Error create datalog\r\n");
 		error_log(ERROR_SD_FILE, true);
+	}
 	// Search for file in current directory and open it
 	fd_datalog = open_file_in_dir(fs, dd, dataFilename);
 	if(!fd_datalog)
+	{
 		serial0_sendString("Error open datalog!\r\n");
 		error_log(ERROR_SD_FILE, true);
 		return;
+	}
 	dataOffset=0;
 	if(!fat_seek_file(fd_datalog, &dataOffset, FAT_SEEK_SET))
+	{
 		// Error seeking to file
 		serial0_sendString("Error seek datalog!\r\n");
 		error_log(ERROR_SD_FILE, true);
 		fat_close_file(fd_datalog);
 		return;
+	}
 	// Write header information
 	logger_log(LOGGER_HEADERTEXT);
 	logger_log("\n-- BEGIN DATA --\n");
 	error_log_rawwrite(LOGGER_HEADERTEXT);
 	error_log_rawwrite("\n-- BEGIN ERROR --\n");
 	error_log_rawwrite("\nErrorNo,ErrorMsg,ErrorInfo,\r\n");
+}
 void logger_log(char *buffer)
+{
 	uint8_t len = strlen(buffer);
 	if(fat_write_file(fd_datalog, (uint8_t*) buffer, len) != len)
+	{
 		// Error writing to file
 		return;
+	}
+}
 void error_log(uint8_t errNo, bool flashLED)
+{
 	char labelBuffer[32];
 	labelBuffer[0] = 0x00;
 	if(errNo <= MAX_ERRNO)
+	{
 		strncpy_P(labelBuffer,(char*)pgm_read_word(&(errorMessageLookup[errNo])),32);
+	}
 	char errorLine[128];
 	snprintf(errorLine, 128, "%lu, %u, %s,,\r\n", time_millis(), errNo, labelBuffer);
 	error_log_rawwrite(errorLine);
 	led_on(LED_ERROR);

master/master/lib/sdcard/sd_raw.c

➞

Show inline comments

@@ @@ -248,208 +248,205 @@ uint8_t sd_raw_init() @@
         /* determine SD/MMC card type */
         sd_raw_send_command(CMD_APP, 0);
         response = sd_raw_send_command(CMD_SD_SEND_OP_COND, 0);
         if((response & (1 << R1_ILL_COMMAND)) == 0)
+        {
             /* card conforms to SD 1 card specification */
             sd_raw_card_type |= (1 << SD_RAW_SPEC_1);
+        }
         else
+        {
             /* MMC card */
+        }
+    }
     /* wait for card to get ready */
     for(uint16_t i = 0; ; ++i)
+    {
         if(sd_raw_card_type & ((1 << SD_RAW_SPEC_1) | (1 << SD_RAW_SPEC_2)))
+        {
             uint32_t arg = 0;
 #if SD_RAW_SDHC
             if(sd_raw_card_type & (1 << SD_RAW_SPEC_2))
                 arg = 0x40000000;
 #endif
             sd_raw_send_command(CMD_APP, 0);
             response = sd_raw_send_command(CMD_SD_SEND_OP_COND, arg);
+        }
         else
+        {
             response = sd_raw_send_command(CMD_SEND_OP_COND, 0);
+        }
         if((response & (1 << R1_IDLE_STATE)) == 0)
             break;
         if(i == 0x7fff)
+        {
             unselect_card();
             return 0;
+        }
+    }
 #if SD_RAW_SDHC
     if(sd_raw_card_type & (1 << SD_RAW_SPEC_2))
+    {
         if(sd_raw_send_command(CMD_READ_OCR, 0))
+        {
             unselect_card();
             return 0;
+        }
         if(sd_raw_rec_byte() & 0x40)
             sd_raw_card_type |= (1 << SD_RAW_SPEC_SDHC);
         sd_raw_rec_byte();
         sd_raw_rec_byte();
         sd_raw_rec_byte();
+    }
 #endif
     /* set block size to 512 bytes */
     if(sd_raw_send_command(CMD_SET_BLOCKLEN, 512))
+    {
         unselect_card();
         return 0;
+    }
     /* deaddress card */
     unselect_card();
     /* switch to highest SPI frequency possible */
     SPCR &= ~((1 << SPR1) | (1 << SPR0)); /* Clock Frequency: f_OSC / 4 */
     SPSR |= (1 << SPI2X); /* Doubled Clock Frequency: f_OSC / 2 */
 #if !SD_RAW_SAVE_RAM
     /* the first block is likely to be accessed first, so precache it here */
     raw_block_address = (offset_t) -1;
 #if SD_RAW_WRITE_BUFFERING
     raw_block_written = 1;
 #endif
     if(!sd_raw_read(0, raw_block, sizeof(raw_block))) {
 		return 0;
+	}
 #endif
     return 1;
+}
 /**
  * \ingroup sd_raw
  * Checks wether a memory card is located in the slot.
+ *
  * \returns 1 if the card is available, 0 if it is not.
  */
 uint8_t sd_raw_available()
+{
 	int i;
 	return 1; // !!TODO: OH GOSH CHANGE ME
 	return 1; // EMZ: Assume always available
     return get_pin_available() == 0x00;
+}
 /**
  * \ingroup sd_raw
  * Checks whether the memory card is locked for write access.
+ *
  * \returns 1 if the card is locked, 0 if it is not.
  */
 uint8_t sd_raw_locked()
+{
 	int i;
 	// !!TODO oh gosh change me
 	return 0;
 	return 0; // EMZ: Assume always unlocked
     return get_pin_locked() == 0x00;
+}
 /**
  * \ingroup sd_raw
  * Sends a raw byte to the memory card.
+ *
  * \param[in] b The byte to sent.
  * \see sd_raw_rec_byte
  */
 void sd_raw_send_byte(uint8_t b)
+{
     SPDR = b;
     /* wait for byte to be shifted out */
     while(!(SPSR & (1 << SPIF)));
     SPSR &= ~(1 << SPIF);
+}
 /**
  * \ingroup sd_raw
  * Receives a raw byte from the memory card.
+ *
  * \returns The byte which should be read.
  * \see sd_raw_send_byte
  */
 uint8_t sd_raw_rec_byte()
+{
     /* send dummy data for receiving some */
     SPDR = 0xff;
     while(!(SPSR & (1 << SPIF)));
     SPSR &= ~(1 << SPIF);
     return SPDR;
+}
 /**
  * \ingroup sd_raw
  * Send a command to the memory card which responses with a R1 response (and possibly others).
+ *
  * \param[in] command The command to send.
  * \param[in] arg The argument for command.
  * \returns The command answer.
  */
 uint8_t sd_raw_send_command(uint8_t command, uint32_t arg)
+{
     uint8_t response;
     /* wait some clock cycles */
     sd_raw_rec_byte();
     /* send command via SPI */
     sd_raw_send_byte(0x40 | command);
     sd_raw_send_byte((arg >> 24) & 0xff);
     sd_raw_send_byte((arg >> 16) & 0xff);
     sd_raw_send_byte((arg >> 8) & 0xff);
     sd_raw_send_byte((arg >> 0) & 0xff);
     switch(command)
+    {
         case CMD_GO_IDLE_STATE:
            sd_raw_send_byte(0x95);
            break;
         case CMD_SEND_IF_COND:
            sd_raw_send_byte(0x87);
            break;
         default:
            sd_raw_send_byte(0xff);
            break;
+    }
     /* receive response */
     for(uint8_t i = 0; i < 10; ++i)
+    {
         response = sd_raw_rec_byte();
         if(response != 0xff)
             break;
+    }
     return response;
+}
 /**
  * \ingroup sd_raw
  * Reads raw data from the card.
+ *
  * \param[in] offset The offset from which to read.
  * \param[out] buffer The buffer into which to write the data.
  * \param[in] length The number of bytes to read.
  * \returns 0 on failure, 1 on success.
  * \see sd_raw_read_interval, sd_raw_write, sd_raw_write_interval
  */
 uint8_t sd_raw_read(offset_t offset, uint8_t* buffer, uintptr_t length)
+{
     offset_t block_address;
     uint16_t block_offset;
     uint16_t read_length;

master/master/lib/slavesensors.c

➞

Show inline comments

@@ @@ -393,178 +393,178 @@ int xbeeIsOk() @@
 		error_log(ERROR_SLAVETIMEOUT, true);
 		return 1;
+	}
+}
 bool slavesensors_dataReady()
+{
 	return dataReady;
+}
 bool slavesensors_isrequesting()
+{
 	return requesting;
+}
 void slavesensors_startprocess()
+{
 	requesting = true;
 	slavesensors_request();
+}
 // TODO: inline. static.
 uint32_t beginRequest = 0;
 void slavesensors_request()
+{
 	slavesensors_selectnode(currentSlave);
 	beginRequest = time_millis();
 	serial_sendCommand("@"); // Request data!
+}
 uint8_t numReadingsToExpect = 0; // number of values that the slave is about to send
 uint8_t numRetries = 0;
 void gotoNextSlaveOrSensor(bool fail) {
 	// If we finished all sensors for all slaves
 	if(currentSlave >= (nodeCount-1) && currentSlaveSensor >= (numReadingsToExpect-1))
+	{
 		#ifdef DEBUG_GETSLAVEDATA
 		serial0_sendString("We got all data for all slaves!\r\n");
 		#endif
 		dataReady = true;
 		currentSlave = 0;
 		currentSlaveSensor = 0;
 		requesting = false;
 		if(!fail)
+		{
 			led_alert();
+		}
+	}
 	// If we finished up one slave, go to the next
 	else if(currentSlaveSensor >= (numReadingsToExpect-1))
+	{
 		#ifdef DEBUG_GETSLAVEDATA
 		serial0_sendString("Finished up one slave, go to another.\r\n");
 		#endif
 		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
+	{
 		#ifdef DEBUG_GETSLAVEDATA
 		serial0_sendString("Give me another sensor value...");
 		#endif
 		// request data for the current sensor of the current slave
 		currentSlaveSensor++;
 		requesting = true;
+	}
+}
 // Request data from slave modules
 void slavesensors_process(uint8_t parseResult)
+{
 	if(!requesting)
+	{
 		// we got a command when we didn't request anything. skip it.
 		return;
+	}
 	// TODO: If we time out, WE NEED TO RESET THE PARSER. It could be in a bad state.
 	else if(parseResult == PARSERESULT_NODATA)
+	{
 		// Wait for data
 		if(requesting && time_millis() - beginRequest > TIMEOUT_SLAVEREQUEST) {
 			// if we're requesting, we have no data, and we're over the timeout, this is bad!
 			// setParserState(STATE_RESET); - meh, can't do this because it freaking increments the cirbufptr
 			gotoNextSlaveOrSensor(true);
-			char* msg[128];
 			char msg[128];
 			snprintf(msg, 128, "Slave %u (%s) timeout",currentSlave,slaveNames[currentSlave]);
 			error_log_msg(ERROR_SLAVETIMEOUT, false, msg); // log error, don't blink LED
+		}
+	}
 	// 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)
+	{
 		#ifdef DEBUG_GETSLAVEDATA
 		char debug[50];
 		snprintf(debug, 50, "Slave %u sensor %u of total nodes %u\r\n", currentSlave, currentSlaveSensor,nodeCount);
 		serial0_sendString(debug);
 		#endif
 		// We got data, reset retries
 		numRetries = 0;
 		// We got some data, let's handle it
 		// ASCII payload
 		uint8_t len = getPayloadLength();
 		char* load = getPayload();
 		uint8_t type = getPayloadType();
 		int32_t parsedVal = strtol(load, NULL, 10);//atoi(load);
 		// Special case for slave telling us how many things we're about to get
 		if(type + 0x30 == '@')
+		{
 			#ifdef DEBUG_GETSLAVEDATA
 			serial0_sendString("Got an awesome count!\r\n");
 			serial0_sendChar(parsedVal + 0x30);
 			serial0_sendString("\r\n");
 			#endif
 			numReadingsToExpect = parsedVal;
 			currentSlaveSensor = 0;
 			requesting = true;
+		}
 		else
+		{
 			// Store data in structure
 			sensordata_set(currentSlave,type,parsedVal);
 			#ifdef DEBUG_GETSLAVEDATA
 			serial0_sendString("Stored some sexy data!\r\n");
 			#endif
 			gotoNextSlaveOrSensor(false);
+		}
+	}
 	// 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)
+		{
 			if(numRetries < MAX_SLAVEREQUEST_RETRIES)
+			{
 				slavesensors_request();	// re-request
+			}
 			else {
 				numRetries = 0;
 				gotoNextSlaveOrSensor(true);
+			}
+		}
+	}
 	else if(parseResult == PARSERESULT_STILLPARSING)
+	{
 		return; // do nothing
+	}
 	else
+	{
 		error_log_msg(ERROR_FATAL, true, "parseResult is invalid!");
 		return;
+	}
+}
@@ \ No newline at end of file @@

master/master/master.c

➞

Show inline comments

@@ @@ -51,106 +51,109 @@ int main(void) @@
 	i2c_init();
 	sensordata_setup(); // must happen before slavesensors/logger/AFSK
 	slavesensors_setup();
 	logger_setup();
 	afsk_setup();
 	serial0_sendString("\r\nHello.\r\n\r\n");
 	// Blocking ZigBee node discovery
 	slavesensors_network_scan();
 	// Software timers
 	uint32_t lastAprsBroadcast = 0;
 	uint32_t lastLog = 0;
 	uint32_t lastLedCycle = 0;
 	uint32_t lastDataReq = 0;
 	// Result of last parser run
 	int parseResult = PARSERESULT_NODATA;
 	// FIXME: Probably don't need this.
 	serial1_ioff();
 	while(1)
+    {
 		// Periodic: LED execution indicator
 		if(time_millis() - lastLedCycle > LEDCYCLE_RATE)
+		{
 			led_spin();
 			// Enable GPS serial interrupts if we aren't doing AFSK
 			if(!afsk_busy())
 				serial1_ion();
 			lastLedCycle = time_millis();
+		}
 		// Periodic: Logging
 		if(time_millis() - lastLog > LOGGER_RATE)
+		{
 			led_on(LED_CYCLE);
 			heater_regulateTemp();
 			// Turn on sideboard LED if we have a fix
 			if(gps_hasfix())
+			{
 				led_on(LED_SIDEBOARD);
+			}
 			else
+			{
 				led_off(LED_SIDEBOARD);
+			}
 			sensors_readBoardTemp();
 			// Write CSV header and log data values
 			sensordata_logvalues();
 			led_off(LED_CYCLE);
 			lastLog = time_millis();
+		}
 		// Periodic: Data Request
 		if(time_millis() - lastDataReq > DATAREQUEST_RATE)
+		{
 			// Start getting values for next transmission
 			if(slavesensors_isrequesting())
+			{
 				// TODO: something is terribly wrong. Timeout?
+			}
 			else
+			{
 				slavesensors_startprocess();
+			}
 			lastDataReq = time_millis();
+		}
 		// Periodic: APRS transmission
 		if(time_millis() - lastAprsBroadcast > APRS_TRANSMIT_PERIOD)
+		{
 			// Ensure we aren't already transmitting
 			while(afsk_busy());
 			// Turn off interrupts and transmit APRS sentence
 			serial1_ioff();
 			aprs_send(); // non-blocking
 			lastAprsBroadcast = time_millis();
+		}
 		// Parse any serial data in the XBee software buffer
 		parseResult = serparser_parse();
 		slavesensors_process(parseResult);
 		// Parse any NMEA messages in the GPS software buffer
 		parse_gps_transmission();
 		wdt_reset();
+    }
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)