seniordesign-firmware Changeset - a5d9aa0655fc

Changeset - a5d9aa0655fc

Parent rev.

Child rev.

[Not reviewed]

default

2 10 0

ethanzonca@CL-ENS241-08.cedarville.edu - 12 years ago 2013-03-14 16:48:00
ethanzonca@CL-ENS241-08.cedarville.edu

Added battery voltage, documentation, refactoring, etc.

12 files changed with 62 insertions and 91 deletions:

master/master/config.h

master/master/lib/boardtemp.c

master/master/lib/boardtemp.h

master/master/lib/heater.c

master/master/lib/led.c

master/master/lib/led.h

master/master/lib/logger.c

master/master/lib/sdcard/sd_raw.c

master/master/lib/sensordata.c

master/master/lib/watchdog.c

master/master/master.c

master/master/master.cproj

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_
 #include <avr/pgmspace.h>
 // --------------------------------------------------------------------------
 // Hardware settings
 // --------------------------------------------------------------------------
 #define F_CPU 11059200
 #define BOARDTEMP_ADDR 0x90
 // --------------------------------------------------------------------------
 // Module config (master.c)
 // --------------------------------------------------------------------------
 // Debug Output
 //#define DEBUG_OUTPUT
 // Blackout (turn off all but power LEDs)
 #define BLACKOUT_ENABLE
 #define BLACKOUT_TIMEOUT 300000 // Blackout after 5 minutes (hopefully after fix)
 #define F_CPU 11059200
 #define MODULE_ID '1'
 #define BOARDTEMP_ADDR 0x90
 // Board heater setpoint
 #define HEATER_THRESHOLD 60
-// Touchdown buzzer settings
 // Touchdown buzzer
 #define BUZZER_RATE 3000
 #define BUZZER_DURATION 1
 #define BUZZER_FAILSAFE_DURATION 600000
 #define BUZZER_TRIGGER_MINDURATION 1
 #define BUZZER_TRIGGER_MAXALTITUDE 1
 // --------------------------------------------------------------------------
-// Error Codes config (led.c, used throughout code)
+// Error Codes config (logger.c)
 // --------------------------------------------------------------------------
 // SD Card
 #define ERROR_SLAVETIMEOUT 0
 #define ERROR_SD_INIT 1
 #define ERROR_SD_PARTITION 2
 #define ERROR_SD_FILE 3
 #define ERROR_XBEETIMEOUT 4
 #define ERROR_FATAL 5
 #define ERROR_ATFAIL 6
 #define ERROR_EXITAT 7
 #define ERROR_INFOTEXT 8
 // !!! Please specify detailed messages for these error codes in logger.c
 // !!! Please specify/update detailed messages for these error codes in logger.c
 // --------------------------------------------------------------------------
 // Slave Sensors config (slavesensors.c)
 // --------------------------------------------------------------------------
 #define MAX_NUM_SLAVES 5  // Maximum number of nodes in the system
 #define MAX_NUM_SENSORS 10 // Maximum number of unique types of sensors in the system
 // Slave data structure size
 #define MAX_NUM_SLAVES 5	// Maximum number of nodes in the system
 #define MAX_NUM_SENSORS 10	// Maximum number of unique types of sensors in the system
 // Node identifier of log destination xbee
 #define XBEE_LOGDEST_NAME "HAB-LOGGER"
 // Rate to request data from slaves. Must be greater than AT delay * number slaves
 #define DATAREQUEST_RATE 3000
 // Timeouts
 #define TIMEOUT_SLAVEREQUEST 1000
 #define TIMEOUT_NETWORKSCAN 7000
 #define TIMEOUT_EXITAT 2000
 #define TIMEOUT_XBEERESPONSE 2000
-// Retries
+// Slave data request max retries (for retry upon corrupt data reception)
 #define MAX_SLAVEREQUEST_RETRIES 2
 // --------------------------------------------------------------------------
 // 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 128
 // Public broadcast address
 #define BROADCAST_ADDR 0
 // --------------------------------------------------------------------------
 // GPS config (xxx.c)
 // --------------------------------------------------------------------------
 // NMEA circular buffer size. Must be large enough to hold all received sentences
 #define NMEABUFFER_SIZE 150
 // --------------------------------------------------------------------------
 // USART config (serial.c)
 // --------------------------------------------------------------------------
 // Baud rates for XBEE and GPS serial ports
 #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
 // Transmit the APRS sentence every X milliseconds
 #define APRS_TRANSMIT_PERIOD 20000
 // --------------------------------------------------------------------------
 // Logger config (logger.c)
 // --------------------------------------------------------------------------
 // Log number EEPROM address (this number is incremented on boot, used for filenames)
 #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/boardtemp.c

➞

Show inline comments

deleted file

master/master/lib/boardtemp.h

➞

Show inline comments

deleted file

master/master/lib/heater.c

➞

Show inline comments

 /*
  * Master Firmware: Board Heater
+ *
  * Wireless Observational Modular Aerial Network
+ *
  * Ethan Zonca
  * Matthew Kanning
  * Kyle Ripperger
  * Matthew Kroening
+ *
  */
 #include "../config.h"
 #include "led.h"
-#include "boardtemp.h"
+#include "sensors.h"
  void heater_regulateTemp()
+ {
 	 // Gets board temperature and enables heater if below threshold
 	 if (sensors_getBoardTemp() <= HEATER_THRESHOLD)
+	 {
 		 led_on(LED_HEAT);
 		 led_on(LED_STATUS);
+	 }
 	 else if (sensors_getBoardTemp() > (HEATER_THRESHOLD + 5))
+	 {
 		 led_off(LED_HEAT);
 		 led_off(LED_STATUS);
+	 }
+ }
@@ \ No newline at end of file @@

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 <stdbool.h>
 #include "led.h"
 bool blackout = false;
 // 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
+	}
 	// Beep on startup
 	OCR0B = 30; // Power LED
 	led_on(LED_BUZZ);
 	_delay_ms(1);
 	led_off(LED_BUZZ);
+}
 void led_power_toggle()
+{
 	OCR0B ^= 30;
+}
 // Turn the specified LED on
 void led_on(uint8_t led)
+{
 	if(blackout && led != LED_ERROR && led != LED_BUZZ)
+	{
 		return;
+	}
 	*(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)
+{
 	if(blackout && led != LED_ERROR && led != LED_BUZZ)
+	{
 		return;
+	}
 	*(ledList[led].port) ^= (1<<ledList[led].pin);
+}
 void led_blackout() {
 	if(!blackout)
+	{
 		blackout = true;
 		for(int i=0; i<NUM_LEDS; i++)
+		{
 			if(i != LED_ERROR)
+			{
 				*(ledList[i].port) &= ~(1<<ledList[i].pin); // set pin low
+			}
+		}
+	}
+}
 bool led_isBlackout()
+{
 	return blackout;
+}
 // 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++)
+	{
 		// Direct port writing done here to show error LED during blackout
 		led_on(LED_ERROR);
 		_delay_ms(150);
 		led_off(LED_ERROR);
 		_delay_ms(150);
+	}
 	_delay_ms(400);
 	// Direct port writing done here to show error LED during blackout
 	led_on(LED_ERROR);
+}
 void led_alert()
+{
 	if(blackout)
+	{
 		return;
+	}
 	led_on(LED_ACT0);
 	led_on(LED_ACT1);
 	led_on(LED_ACT2);
 	led_on(LED_ACT3);
 	_delay_ms(10);
+}
 uint8_t ctr = 0;
 void led_spin()
+{
 	if(blackout)
+	{
 		return;
+	}
 	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;
+}
 bool pulseUp = true;
 void led_pulsate()
+{
 	if(blackout)
+	{
 		return;
+	}
 	if(OCR0B >= 240 && pulseUp)
 		pulseUp = false;
 	else if(OCR0B <= 12 && !pulseUp);
 		pulseUp = true;
 	if(pulseUp)
 		OCR0B+=5;
 	else
 		OCR0B-=5;
+}
@@ \ 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>
 #include <stdbool.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 {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_power_toggle();
 void led_on(uint8_t led);
 void led_off(uint8_t led);
 void led_toggle(uint8_t led);
 void led_blackout();
 bool led_isBlackout();
 void led_errorcode(uint8_t code);
 void led_spin();
 void led_alert();
 #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 "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((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);

master/master/lib/sdcard/sd_raw.c

➞

Show inline comments

 /*
  * Copyright (c) 2006-2012 by Roland Riegel <feedback@roland-riegel.de>
+ *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of either the GNU General Public License version 2
  * or the GNU Lesser General Public License version 2.1, both as
  * published by the Free Software Foundation.
  */
 #include <string.h>
 #include <avr/io.h>
 #include "sd_raw.h"
 #include "sd_raw_config.h"
 #include "../led.h"
 #include <avr/delay.h>
 /**
  * \addtogroup sd_raw MMC/SD/SDHC card raw access
+ *
  * This module implements read and write access to MMC, SD
  * and SDHC cards. It serves as a low-level driver for the
  * higher level modules such as partition and file system
  * access.
+ *
  * @{
  */
 /**
  * \file
  * MMC/SD/SDHC raw access implementation (license: GPLv2 or LGPLv2.1)
+ *
  * \author Roland Riegel
  */
 /**
  * \addtogroup sd_raw_config MMC/SD configuration
  * Preprocessor defines to configure the MMC/SD support.
  */
 /**
  * @}
  */
 /* commands available in SPI mode */
 /* CMD0: response R1 */
 #define CMD_GO_IDLE_STATE 0x00
 /* CMD1: response R1 */
 #define CMD_SEND_OP_COND 0x01
 /* CMD8: response R7 */
 #define CMD_SEND_IF_COND 0x08
 /* CMD9: response R1 */
 #define CMD_SEND_CSD 0x09
 /* CMD10: response R1 */
 #define CMD_SEND_CID 0x0a
 /* CMD12: response R1 */
 #define CMD_STOP_TRANSMISSION 0x0c
 /* CMD13: response R2 */
 #define CMD_SEND_STATUS 0x0d
 /* CMD16: arg0[31:0]: block length, response R1 */
 #define CMD_SET_BLOCKLEN 0x10
 /* CMD17: arg0[31:0]: data address, response R1 */
 #define CMD_READ_SINGLE_BLOCK 0x11
 /* CMD18: arg0[31:0]: data address, response R1 */
 #define CMD_READ_MULTIPLE_BLOCK 0x12
 /* CMD24: arg0[31:0]: data address, response R1 */
 #define CMD_WRITE_SINGLE_BLOCK 0x18
 /* CMD25: arg0[31:0]: data address, response R1 */
 #define CMD_WRITE_MULTIPLE_BLOCK 0x19
 /* CMD27: response R1 */
 #define CMD_PROGRAM_CSD 0x1b
 /* CMD28: arg0[31:0]: data address, response R1b */
 #define CMD_SET_WRITE_PROT 0x1c
 /* CMD29: arg0[31:0]: data address, response R1b */
 #define CMD_CLR_WRITE_PROT 0x1d
 /* CMD30: arg0[31:0]: write protect data address, response R1 */
 #define CMD_SEND_WRITE_PROT 0x1e
 /* CMD32: arg0[31:0]: data address, response R1 */
 #define CMD_TAG_SECTOR_START 0x20
 /* CMD33: arg0[31:0]: data address, response R1 */
 #define CMD_TAG_SECTOR_END 0x21
 /* CMD34: arg0[31:0]: data address, response R1 */
 #define CMD_UNTAG_SECTOR 0x22
 /* CMD35: arg0[31:0]: data address, response R1 */
 #define CMD_TAG_ERASE_GROUP_START 0x23
 /* CMD36: arg0[31:0]: data address, response R1 */
 #define CMD_TAG_ERASE_GROUP_END 0x24
 /* CMD37: arg0[31:0]: data address, response R1 */
 #define CMD_UNTAG_ERASE_GROUP 0x25
 /* CMD38: arg0[31:0]: stuff bits, response R1b */
 #define CMD_ERASE 0x26
 /* ACMD41: arg0[31:0]: OCR contents, response R1 */
 #define CMD_SD_SEND_OP_COND 0x29
 /* CMD42: arg0[31:0]: stuff bits, response R1b */
 #define CMD_LOCK_UNLOCK 0x2a
 /* CMD55: arg0[31:0]: stuff bits, response R1 */
 #define CMD_APP 0x37
 /* CMD58: arg0[31:0]: stuff bits, response R3 */
 #define CMD_READ_OCR 0x3a
 /* CMD59: arg0[31:1]: stuff bits, arg0[0:0]: crc option, response R1 */
 #define CMD_CRC_ON_OFF 0x3b
 /* command responses */
 /* R1: size 1 byte */
 #define R1_IDLE_STATE 0
 #define R1_ERASE_RESET 1
 #define R1_ILL_COMMAND 2
 #define R1_COM_CRC_ERR 3
 #define R1_ERASE_SEQ_ERR 4
 #define R1_ADDR_ERR 5
 #define R1_PARAM_ERR 6
 /* R1b: equals R1, additional busy bytes */
@@ @@ -226,203 +228,206 @@ uint8_t sd_raw_init() @@
             return 0;
+        }
+    }
 #if SD_RAW_SDHC
     /* check for version of SD card specification */
     response = sd_raw_send_command(CMD_SEND_IF_COND, 0x100 /* 2.7V - 3.6V */ | 0xaa /* test pattern */);
     if((response & (1 << R1_ILL_COMMAND)) == 0)
+    {
         sd_raw_rec_byte();
         sd_raw_rec_byte();
         if((sd_raw_rec_byte() & 0x01) == 0)
             return 0; /* card operation voltage range doesn't match */
         if(sd_raw_rec_byte() != 0xaa)
             return 0; /* wrong test pattern */
         /* card conforms to SD 2 card specification */
         sd_raw_card_type |= (1 << SD_RAW_SPEC_2);
+    }
     else
 #endif
+    {
         /* 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()
+{
 	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()
+{
 	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)

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 <stdio.h>
 #include <stdbool.h>
 #include <string.h>
 #include "sensordata.h"
 #include "slavesensors.h"
-#include "boardtemp.h"
+#include "sensors.h"
 #include "looptime.h"
 #include "gps.h"
 #include "logger.h"
 // Slave sensor reading storage
 int32_t slaves[MAX_NUM_SLAVES][MAX_NUM_SENSORS];
 void sensordata_setup()
+{
 	for(int i=0; i<MAX_NUM_SLAVES; i++)
+	{
 		for(int j=0; j<MAX_NUM_SENSORS; j++)
+		{
 			slaves[i][j] = -2111111111; // minimum value of 16 bit integer
+		}
+	}
+}
 // Store a sensor value in memory
 void sensordata_set(uint8_t nodeID, uint8_t type, int32_t value)
+{
 	if(nodeID < MAX_NUM_SLAVES)
+	{
 		slaves[nodeID][type] = value;
+	}
+}
 // Retrieve a sensor value from memory
 int32_t sensordata_get(uint8_t nodeID, uint8_t type)
+{
 	// Avoid reading out of bad places!
 	if(nodeID < MAX_NUM_SLAVES)
+	{
 		return slaves[nodeID][type];
+	}
 	else
+	{
 		return 0;
+	}
+}
 bool isEven = false;
 // Generate APRS comment
 // TODO: Can we move this buffer to a local scope of this function?
 char* slavesensors_getAPRScomment(char* commentBuffer, uint16_t bufferSize)
+{
 	snprintf(commentBuffer,bufferSize, "t9%d~s%s~v%s~h%s~_%s~|%s", sensors_getBoardTemp(), get_sv(), get_speedKnots(), get_hdop(), get_latitudeLSBs(), get_longitudeLSBs());
 	if(isEven)
+	{
 		// Find slave sensors to include in this log
 		for(int i=0; i<MAX_NUM_SLAVES; i++)
+		{
 			// Board temperature sensors (all slaves)
 			uint32_t val = sensordata_get(i, SENSOR_BOARDTEMP);
 			if(val != -2111111111) {
 				uint16_t len = strlen(commentBuffer);
 				snprintf(commentBuffer + len, bufferSize-len, "~t%u%li",i,val);
+			}
 			// Battery voltages (all slaves)
 			val = sensordata_get(i, SENSOR_BATTERYLEVEL);
 			if(val != -2111111111) {
 				uint16_t len = strlen(commentBuffer);
 				snprintf(commentBuffer + len, bufferSize-len, "~l%u%li",i,val);
+			}
 			// Pressure
 			val = sensordata_get(i, SENSOR_PRESSURE);
 			if(val != -2111111111) {
 				uint16_t len = strlen(commentBuffer);
 				snprintf(commentBuffer + len, bufferSize-len, "~P%li",val);
+			}
 			// Air Temperature
 			val = sensordata_get(i, SENSOR_AIRTEMP);
 			if(val != -2111111111) {
 				uint16_t len = strlen(commentBuffer);
 				snprintf(commentBuffer + len, bufferSize-len, "~C%li",val);
+			}
 			// Altitude
 			val = sensordata_get(i, SENSOR_ALTITUDE);
 			if(val != -2111111111) {
 				uint16_t len = strlen(commentBuffer);
 				snprintf(commentBuffer + len, bufferSize-len, "~A%li",val);
+			}
 			// Radiation
 			val = sensordata_get(i, SENSOR_CPM_RADIATION);
 			if(val != -2111111111) {
 				uint16_t len = strlen(commentBuffer);
 				snprintf(commentBuffer + len, bufferSize-len, "~R%li",val);
+			}
+		}
 		isEven = false;
+	}
 	else {
 		// odd does nothing
 		isEven = true;
+	}
 	if(logger_aprsInfoTextAvailable())
+	{
 		uint16_t len = strlen(commentBuffer);
 		snprintf(commentBuffer + len, bufferSize-len, "~%s",logger_getAprsInfoText());
 		logger_aprsInfoTextConsumed();
+	}
 	return commentBuffer;
+}
 // Generates CSV headers on first run and logs values to the SD card (if data available)
 bool dataWasReady = false;
 void sensordata_logvalues()
+{
 	// Generate CSV header after we have queried all slaves once
 	if(slavesensors_dataReady())
+	{
 		// Only generate/write header the first time data is ready
 		if(!dataWasReady)
+		{
 			#define CSV_BUFFER_SIZE 64
 			char csvHeader[CSV_BUFFER_SIZE];
 			csvHeader[0] = 0x00;
 			// Add master data headers
 			logger_log("Time,BoardTemp,GPSTime,GPSLat,GPSLon,GPSSpeed,GPSHDOP,GPSCourse,GPSSV,");
+			logger_log("Time,BoardTemp,VBatt,GPSTime,GPSLat,GPSLon,GPSSpeed,GPSHDOP,GPSCourse,GPSSV,");
 			// Add slave data headers
 			for(uint8_t i=0; i<MAX_NUM_SLAVES; i++)
+			{
 				for(uint8_t j=0; j<MAX_NUM_SENSORS; j++)
+				{
 					int32_t tmp = sensordata_get(i, j);
 					// If a sensor value exists, write a header for it
 					if(tmp != -2111111111)
+					{
 						snprintf(csvHeader, CSV_BUFFER_SIZE,"%s-%s,", slavesensors_slavename(i), slavesensors_getLabel(j));
 						logger_log(csvHeader);
+					}
+				}
+			}
 			// End line and write to SD card
 			snprintf(csvHeader, CSV_BUFFER_SIZE,"\r\n");
 			logger_log(csvHeader);
 			dataWasReady = true;
+		}
 		// Write CSV sensor values to SD card
 		#define CSV_LOGLINE_SIZE 512
 		char logbuf[CSV_LOGLINE_SIZE];
 		logbuf[0] = 0x00;
 		// Write master sensor values
 		snprintf(logbuf, CSV_LOGLINE_SIZE, "%lu,%d,%s,%s,%s,%s,%s,%s,%s,", time_millis(), sensors_getBoardTemp(),get_timestamp(),get_latitudeTrimmed(),get_longitudeTrimmed(),get_speedKnots(),get_hdop(), get_course(), get_sv());
+		snprintf(logbuf, CSV_LOGLINE_SIZE, "%lu,%d,%u,%s,%s,%s,%s,%s,%s,%s,", time_millis(), sensors_getBoardTemp(), sensors_getBatt(), get_timestamp(),get_latitudeTrimmed(),get_longitudeTrimmed(),get_speedKnots(),get_hdop(), get_course(), get_sv());
 		// Write slave sensor values
 		for(int i=0; i<MAX_NUM_SLAVES; i++)
+		{
 			for(int j=0; j<MAX_NUM_SENSORS; j++)
+			{
 				int32_t tmp = sensordata_get(i, j);
 				// If a sensor value exists, log the data
 				if(tmp != -2111111111)
+				{
 					snprintf(logbuf + strlen(logbuf),CSV_LOGLINE_SIZE-strlen(logbuf)," %ld,", tmp);
+				}
+			}
+		}
 		// End line and write to log
 		snprintf(logbuf + strlen(logbuf),CSV_LOGLINE_SIZE-strlen(logbuf),"\r\n");
 		logger_log(logbuf);
+	}
+}
 bool isTouchdown = false;
 bool sensordata_isTouchdown()
+{
 	return isTouchdown;
+}
 int32_t sensordata_getSensorValue(uint8_t sensorID)
+{
 	// Loop through all slaves
 	for(int i=0; i<MAX_NUM_SLAVES; i++)
+	{
 		uint32_t val = sensordata_get(i, sensorID);
 		if(val != -2111111111) {
 			return val;
+		}
+	}
 	return -2111111111;
+}
 void sensordata_checkTouchdown()
+{
 	// If we have reached touchdown, never get out of this state
 	if(isTouchdown)
+	{
 		return;
+	}
 	if(time_millis() > BUZZER_FAILSAFE_DURATION)
+	{
 		isTouchdown = true;
+	}
 	else
+	{
 		int32_t altitude = sensordata_getSensorValue(SENSOR_ALTITUDE);
 		if(altitude != -2111111111 && altitude < BUZZER_TRIGGER_MAXALTITUDE && time_millis() > BUZZER_TRIGGER_MINDURATION)
+		{
 			isTouchdown = true;
+		}
+	}
+}
@@ \ No newline at end of file @@

master/master/lib/watchdog.c

➞

Show inline comments

 /*
  * Master Firmware: Watchdog Timer
+ *
  * Wireless Observational Modular Aerial Network
+ *
  * Ethan Zonca
  * Matthew Kanning
  * Kyle Ripperger
  * Matthew Kroening
+ *
  */
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include <avr/wdt.h>
 //initialize watchdog
 void watchdog_setup(void)
+{
 	cli();
 	wdt_reset();
 	// Set change enable bit, enable the WDT
 	WDTCSR = (1<<WDCE)|(1<<WDE);
 	// Start watchdog, 4 second timeout
 	WDTCSR = (1<<WDE)|(1<<WDP3)|(1<<WDP0);
 	sei();
+}
 // ISR for watchdog timeout. Not currently used, interrupt is disabled.
 ISR(WDT_vect)
+{
+}

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 <string.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/sensors.h"
 #include "lib/heater.h"
 #include "lib/looptime.h"
 #include "lib/slavesensors.h"
 #include "lib/serparser.h"
 #include "lib/sensordata.h"
 int main(void)
+{
 	// Power debounce
 	_delay_ms(1000);
 	// Initialize libraries
 	time_setup();
 	watchdog_setup(); // enables interrupts
 	led_setup();
 	gps_setup();
 	serial0_setup();
 	serial1_setup();
 	i2c_init();
 	sensordata_setup(); // must happen before slavesensors/logger/AFSK
 	slavesensors_setup();
 	sensors_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;
 	uint32_t lastBuzz = 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_power_toggle();
 			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();
 			sensors_readBatt();
 			// Write CSV header and log data values
 			sensordata_logvalues();
 			led_off(LED_CYCLE);
 			lastLog = time_millis();
+		}
 		// Periodic: Buzzer
 		if(time_millis() - lastBuzz > BUZZER_RATE) {
 			if(sensordata_isTouchdown())
+			{
 				led_on(LED_BUZZ);
 				_delay_ms(BUZZER_DURATION);
 				led_off(LED_BUZZ);
+			}
 			lastBuzz = 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)
+		{
 			// Check for touchdown
 			sensordata_checkTouchdown();
 			// LED blackout
 			#ifdef BLACKOUT_ENABLE
 			led_blackout();
 			#endif
 			// 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();
+		}
 		#ifdef BLACKOUT_ENABLE
 		bool black = false;
 		if(!black && time_millis() > BLACKOUT_TIMEOUT)
+		{
 			// LED blackout
 			led_blackout();
 			black = true;
+		}
 		#endif
 		// 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 @@

master/master/master.cproj

➞

Show inline comments

 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectVersion>6.0</ProjectVersion>
     <ToolchainName>com.Atmel.AVRGCC8</ToolchainName>
     <ProjectGuid>{8579ec2d-5815-40db-84e0-1d14239c7aea}</ProjectGuid>
     <avrdevice>ATmega644PA</avrdevice>
     <avrdeviceseries>none</avrdeviceseries>
     <OutputType>Executable</OutputType>
     <Language>C</Language>
     <OutputFileName>$(MSBuildProjectName)</OutputFileName>
     <OutputFileExtension>.elf</OutputFileExtension>
     <OutputDirectory>$(MSBuildProjectDirectory)\$(Configuration)</OutputDirectory>
     <AssemblyName>master</AssemblyName>
     <Name>master</Name>
     <RootNamespace>master</RootNamespace>
     <ToolchainFlavour>Native</ToolchainFlavour>
     <KeepTimersRunning>true</KeepTimersRunning>
     <OverrideVtor>false</OverrideVtor>
     <OverrideVtorValue />
     <eraseonlaunchrule>0</eraseonlaunchrule>
     <AsfVersion>3.1.3</AsfVersion>
     <avrtool>com.atmel.avrdbg.tool.ispmk2</avrtool>
     <avrtoolinterface>ISP</avrtoolinterface>
     <com_atmel_avrdbg_tool_simulator>
       <ToolType xmlns="">com.atmel.avrdbg.tool.simulator</ToolType>
       <ToolName xmlns="">AVR Simulator</ToolName>
       <ToolNumber xmlns="">
       </ToolNumber>
       <KeepTimersRunning xmlns="">true</KeepTimersRunning>
       <OverrideVtor xmlns="">false</OverrideVtor>
       <OverrideVtorValue xmlns="">
       </OverrideVtorValue>
       <Channel xmlns="">
         <host>127.0.0.1</host>
         <port>52692</port>
         <ssl>False</ssl>
       </Channel>
     </com_atmel_avrdbg_tool_simulator>
     <com_atmel_avrdbg_tool_ispmk2>
       <ToolType>com.atmel.avrdbg.tool.ispmk2</ToolType>
       <ToolName>AVRISP mkII</ToolName>
       <ToolNumber>000200131077</ToolNumber>
       <KeepTimersRunning>true</KeepTimersRunning>
       <OverrideVtor>false</OverrideVtor>
       <OverrideVtorValue>
       </OverrideVtorValue>
       <Channel>
         <host>127.0.0.1</host>
-        <port>49512</port>
+        <port>55130</port>
         <ssl>False</ssl>
       </Channel>
       <ToolOptions>
         <InterfaceName>ISP</InterfaceName>
         <InterfaceProperties>
           <JtagDbgClock>249000</JtagDbgClock>
           <JtagProgClock>1000000</JtagProgClock>
-          <IspClock>2010000</IspClock>
+          <IspClock>1970000</IspClock>
           <JtagInChain>false</JtagInChain>
           <JtagEnableExtResetOnStartSession>false</JtagEnableExtResetOnStartSession>
           <JtagDevicesBefore>0</JtagDevicesBefore>
           <JtagDevicesAfter>0</JtagDevicesAfter>
           <JtagInstrBitsBefore>0</JtagInstrBitsBefore>
           <JtagInstrBitsAfter>0</JtagInstrBitsAfter>
         </InterfaceProperties>
       </ToolOptions>
     </com_atmel_avrdbg_tool_ispmk2>
     <preserveEEPROM>True</preserveEEPROM>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
     <ToolchainSettings>
       <AvrGcc>
         <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
         <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
         <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
         <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
         <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
         <avrgcc.compiler.optimization.level>Optimize for size (-Os)</avrgcc.compiler.optimization.level>
         <avrgcc.compiler.optimization.PackStructureMembers>True</avrgcc.compiler.optimization.PackStructureMembers>
         <avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
         <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
         <avrgcc.linker.libraries.Libraries>
           <ListValues>
             <Value>m</Value>
           </ListValues>
         </avrgcc.linker.libraries.Libraries>
       </AvrGcc>
     </ToolchainSettings>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <ToolchainSettings>
       <AvrGcc>
         <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
         <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
         <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
         <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
         <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
         <avrgcc.compiler.optimization.level>Optimize (-O1)</avrgcc.compiler.optimization.level>
         <avrgcc.compiler.optimization.PackStructureMembers>True</avrgcc.compiler.optimization.PackStructureMembers>
         <avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
         <avrgcc.compiler.optimization.DebugLevel>Default (-g2)</avrgcc.compiler.optimization.DebugLevel>
         <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
         <avrgcc.linker.libraries.Libraries>
           <ListValues>
             <Value>m</Value>
           </ListValues>
         </avrgcc.linker.libraries.Libraries>
         <avrgcc.assembler.debugging.DebugLevel>Default (-Wa,-g)</avrgcc.assembler.debugging.DebugLevel>
       </AvrGcc>
     </ToolchainSettings>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="config.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\afsk.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\afsk.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\aprs.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\aprs.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\ax25.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\ax25.h">
       <SubType>compile</SubType>
     </Compile>
-    <Compile Include="lib\boardtemp.c">
+    <Compile Include="lib\sensors.c">
       <SubType>compile</SubType>
     </Compile>
-    <Compile Include="lib\boardtemp.h">
+    <Compile Include="lib\sensors.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\gps.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\gps.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\heater.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\heater.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\i2c.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\i2c.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\led.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\led.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\logger.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\logger.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\looptime.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\looptime.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sdcard\byteordering.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sdcard\byteordering.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sdcard\fat.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sdcard\fat.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sdcard\fat_config.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sdcard\partition.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sdcard\partition.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sdcard\partition_config.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sdcard\sd-reader_config.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sdcard\sd_raw.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sdcard\sd_raw.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sdcard\sd_raw_config.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sensordata.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\sensordata.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\serial.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\serial.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\serparser.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\serparser.h">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\slavesensors.c">
       <SubType>compile</SubType>
     </Compile>
     <Compile Include="lib\slavesensors.h">

0 comments (0 inline, 0 general)