Changeset - a20e51697fd8
[Not reviewed]
default
0 7 0
ethanzonca@CL-ENS241-08.cedarville.edu - 12 years ago 2013-01-15 21:35:00
ethanzonca@CL-ENS241-08.cedarville.edu
Initial XBee AT mode and network scan implementation started. Need to store data from network scan in a reasonable manner.
7 files changed with 147 insertions and 6 deletions:
0 comments (0 inline, 0 general)
master/master/config.h
Show inline comments
 
@@ -19,25 +19,27 @@
 
 
#define F_CPU 11059200
 
#define MODULE_ID '1'
 
#define BOARDTEMP_ADDR 0x90
 
 
// --------------------------------------------------------------------------
 
// Error Codes config (led.c, used throughout code)
 
// --------------------------------------------------------------------------
 
 
// SD Card
 
#define ERROR_SD_INIT 2
 
#define ERROR_SD_PARTITION 3
 
#define ERROR_CRAP 6
 
#define ERROR_SD_FILE 4
 
 
#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
master/master/lib/logger.c
Show inline comments
 
@@ -55,65 +55,71 @@ void logger_setup()
 
		serial0_sendString("SD> Error opening partition.\r\n");
 
		// 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
 
	fat_create_file(dd, filename, &directory);
 
	if(!fat_create_file(dd, filename, &directory)) {
 
		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) 
master/master/lib/serial.c
Show inline comments
 
@@ -6,24 +6,25 @@
 
 * Ethan Zonca
 
 * Matthew Kanning
 
 * Kyle Ripperger
 
 * Matthew Kroening
 
 *
 
 */
 
 
#include "serial.h"
 
#include "led.h"
 
#include "../config.h"
 
#include <avr/io.h>
 
#include <avr/interrupt.h>
 
#include <avr/wdt.h>
 
 
// NOTE: USART ISRs for character reception are included in serparser.c
 
 
void serial0_setup() {
 
	//PORTD &= ~(1<<PD0);
 
	//PORTD |= (1<<PD1);
 
	
 
	/* Enable receiver and transmitter */
 
	UCSR0B |= (1<<RXEN0)|(1<<TXEN0); // Enable rx/tx
 
	/* Set frame format: 8data, 1stop bit */
 
	UCSR0C |= (1 << UCSZ00) | (1 << UCSZ01); // - 1 stop bit
 
	
 
@@ -56,36 +57,78 @@ void serial1_setup() {
 
	UCSR1B |= (1 << RXCIE1); // Enable interrupt
 
}
 
 
void serial1_ion() {
 
	UCSR1B |= (1<<RXEN1); // Enable rx
 
	UCSR1B |= (1 << RXCIE1); // Enable interrupt
 
}
 
void serial1_ioff() {
 
	UCSR1B &= ~(1<<RXEN1); // Disable rx
 
	UCSR1B &= ~(1 << RXCIE1); // Disable interrupt
 
}
 
 
void serial0_ion() {
 
	UCSR0B |= (1 << RXCIE0); // Enable interrupt
 
}
 
void serial0_ioff() {
 
	UCSR0B &= ~(1 << RXCIE0); // Disable interrupt
 
}
 
 
 
void serial0_sendChar( unsigned char byte )
 
{
 
	while (!(UCSR0A & (1<<UDRE0)));
 
	UDR0 = byte;
 
}
 
 
void serial1_sendChar( unsigned char byte )
 
{
 
	while (!(UCSR1A & (1<<UDRE1)));
 
	UDR1 = byte;
 
}
 
 
 
unsigned char serial0_readChar()
 
{
 
	while(!(UCSR0A &(1<<RXC0)));
 
	//char c = UDR0;
 
	//serial0_sendString("Read: ");
 
	//serial0_sendChar(c);
 
	//serial0_sendChar('\n');
 
	return UDR0;
 
}
 
 
uint8_t serial0_hasChar() {
 
	return (UCSR0A &(1<<RXC0));
 
}
 
 
char readBuf[128];
 
char* serial0_readLine() {
 
	char c;
 
	
 
	int i = 0;
 
	
 
	while(i < 128) {
 
		c = serial0_readChar();
 
 
		if(c == 0x0D) break;
 
		readBuf[i] = c;
 
		i++;
 
	}
 
	
 
	readBuf[i] = '\0';
 
	return readBuf;
 
}
 
 
 
void serial0_sendString(const char* stringPtr){
 
	while(*stringPtr != 0x00)
 
	{
 
		serial0_sendChar(*stringPtr);
 
		stringPtr++;
 
	}
 
}
 
 
void serial1_sendString(const char* stringPtr){
 
	while(*stringPtr != 0x00)
 
	{
 
		serial1_sendChar(*stringPtr);
master/master/lib/serial.h
Show inline comments
 
@@ -19,19 +19,23 @@
 
#define USART0_BAUD_PRESCALE (((F_CPU / (USART0_BAUDRATE * 16UL))) -1 )
 
#define USART1_BAUD_PRESCALE (((F_CPU / (USART1_BAUDRATE * 16UL))) -1 )
 
 
void serial0_sendChar( unsigned char byte );
 
void serial1_sendChar( unsigned char byte );
 
 
void serial0_setup();
 
void serial1_setup();
 
 
void serial0_sendString(const char* stringPtr);
 
void serial1_sendString(const char* stringPtr);
 
 
unsigned char serial0_readChar();
 
uint8_t serial0_hasChar();
 
char* serial0_readLine();
 
 
void serial_sendCommand( char moduleID, char sensorID, char* data );
 
void serial_sendResponseData();
 
 
void serial1_ion();
 
void serial1_ioff();
 
 
#endif /* SERIAL_H_ */
 
\ No newline at end of file
master/master/lib/slavesensors.c
Show inline comments
 
@@ -7,24 +7,27 @@
 
 * 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 <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++) 
 
@@ -48,44 +51,124 @@ void slavesensors_setup()
 
	slaves[1][4] = AMBIENTLIGHT;
 
	
 
	// slave 2
 
	slaves[2][0] = BOARDTEMP;
 
	slaves[2][1] = GEIGER;
 
	
 
	// slave 3
 
	slaves[3][0] = BOARDTEMP;
 
	slaves[3][1] = CAMERA;
 
	
 
}
 
 
char* bufPtr = 0x00;
 
void slavesensors_network_scan() {
 
	serial0_ioff();
 
	
 
	int atOK;
 
	
 
	serial0_sendString("Beginning network scan...\r\n");
 
	
 
	// Delay guard period
 
	_delay_ms(500);
 
	_delay_ms(500);
 
	
 
	// Enter AT mode
 
	serial0_sendChar('+'); // Enter AT mode
 
	serial0_sendChar('+');
 
	serial0_sendChar('+');
 
	
 
	while(!serial0_hasChar()) {
 
		wdt_reset();
 
	}
 
	bufPtr = serial0_readLine();
 
	
 
	char nameString[20] = "NONE";
 
	
 
	// wait for OK
 
	//todo
 
	if(strcmp(bufPtr, "OK") == 0)
 
	{
 
		atOK = 1;
 
		
 
		serial0_sendString("ATND");
 
		serial0_sendChar(0x0D);
 
		// wait for scan to complete
 
		while(!serial0_hasChar()) {
 
			wdt_reset();
 
		}
 
		
 
		// Scan data end when newline by itself ("")	
 
		int lineCount = 0;	
 
		while(1) {
 
			bufPtr = serial0_readLine();
 
			if(lineCount == 3) {
 
				strcpy(nameString, bufPtr);
 
			}
 
			if(strcmp(bufPtr, "") == 0)
 
				break;
 
			lineCount++;
 
		}		
 
		// Exit AT
 
		serial0_sendString("ATCN");
 
		serial0_sendChar(0x0D);
 

	
 
	}
 
	else {
 
		atOK = 0;
 
	}
 
	_delay_ms(200);
 
	//serial0_sendString("ATND"); // Scan all nodes
 
	
 

	
 
	 
 
	 led_on(LED_SIDEBOARD);
 
	 _delay_ms(500);
 

	
 
	serial0_sendString("First found node is: ");
 
	serial0_sendString(nameString);
 
	serial0_sendString("\r\n");
 
	
 
	if(atOK != 1) {
 
		serial0_sendString("AT mode failed \r\n");
 
	}
 
	
 
	
 
	// 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
 
	serial0_ion();
 
}
 
 
bool slavesensors_isrequesting() 
 
{
 
	return requesting;	
 
}
 
 
void slavesensors_startprocess() 
 
{
 
	requesting = true;
 
	slavesensors_request();		
 
}
 
 
// TODO: inline. static.
 
void slavesensors_request() 
 
{
 
	serial_sendCommand(currentSlave + 0x30, slaves[currentSlave][currentSlaveSensor] + 0x30, "");
 
}
 
 
void slavesensors_process(uint8_t parseResult) 
 
{
 
	
 
	if(!requesting) {
 
		// we got a command when we didn't request anything. probably skip it.
 
		return;
 
	}
 
	
 
	// TODO: timeout. If we're at NODATA for a long time and we are requesting, that's an issue.
 
	else if(parseResult == PARSERESULT_NODATA) {
 
		// Wait for data
 
	}
 
	
 
	// Finished reception of a message (one sensor data value). If not finished, send out command to get the next one
 
	else if(parseResult == PARSERESULT_PARSEOK)
master/master/lib/slavesensors.h
Show inline comments
 
@@ -23,17 +23,18 @@ enum sensorTypes // CMD ID#
 
	NONE = 0,
 
	BOARDTEMP,
 
	PRESSURE,
 
	GEIGER,
 
	TEMPERATURE,
 
	HUMIDITY,
 
	AMBIENTLIGHT,
 
	CAMERA,
 
};
 
 
bool slavesensors_isrequesting();
 
void slavesensors_setup();
 
void slavesensors_network_scan();
 
void slavesensors_startprocess();
 
void slavesensors_request();
 
void slavesensors_process(uint8_t parseResult);
 
 
#endif /* SLAVESENSORS_H_ */
 
\ No newline at end of file
master/master/master.c
Show inline comments
 
@@ -49,24 +49,26 @@ int main(void)
 
	serial1_setup();
 
	i2c_init();
 
	sensordata_setup(); // must happen before sensors/logger/afsk
 
	slavesensors_setup();
 
	logger_setup();
 
	afsk_setup();
 
	//\f
 
	serial0_sendString("\r\n---------------------------------\r\n");
 
	serial0_sendString("HAB Controller 1.0 - Initialized!\r\n");
 
	serial0_sendString("---------------------------------\r\n");
 
	serial0_sendString("\r\nHello.\r\n\r\n");
 
	
 
	slavesensors_network_scan();
 
	
 
	led_on(LED_POWER);
 
	led_off(LED_SIDEBOARD);
 
	
 
	// Buffer for string operations
 
	char logbuf[128];
 
	char debugBuf[128];
 
	
 
	// Software timers	
 
	uint32_t lastAprsBroadcast = 0;
 
	uint32_t lastLog = 0;
 
	uint32_t lastLedCycle = 0;
 
	
 
@@ -120,34 +122,34 @@ int main(void)
 
			lastLedCycle = time_millis();	
 
		}
 
		
 
		// Periodic: Logging
 
		if(time_millis() - lastLog > LOGGER_RATE) 
 
		{
 
			led_on(LED_CYCLE);
 
			
 
			
 
			// 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);
 
			//serial0_sendString(debugBuf);
 
			
 
			
 
			sensors_readBoardTemp(); // i2c read, 400k
 
			snprintf(logbuf, 128, "%lu,%d,%uF,%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
 
			serial0_sendString("LOG> ");
 
			serial0_sendString(logbuf);
 
			//serial0_sendString("LOG> ");
 
			//serial0_sendString(logbuf);
 
			
 
			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
0 comments (0 inline, 0 general)