seniordesign-firmware Changeset - a20e51697fd8

Changeset - a20e51697fd8

Parent rev.

Child rev.

[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:

master/master/config.h

master/master/lib/logger.c

master/master/lib/serial.c

master/master/lib/serial.h

master/master/lib/slavesensors.c

master/master/lib/slavesensors.h

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 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
 #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
 // --------------------------------------------------------------------------
 // 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
 // --------------------------------------------------------------------------

master/master/lib/logger.c

➞

Show inline comments

@@ @@ -19,137 +19,143 @@ @@
 #include <avr/eeprom.h>
 #include <string.h>
 #include "sd/fat.h"
 #include "sd/fat_config.h"
 #include "sd/partition.h"
 #include "sd/sd_raw.h"
 #include "sd/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!
 		serial0_sendString("SD> Error initializing.\r\n");
 		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)
+	{
 		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)
+{
 	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)
+{
 	struct fat_dir_entry_struct file_entry;
 	if(!find_file_in_dir(fs, dd, name, &file_entry))
 	return 0;
 	return fat_open_file(fs, &file_entry);
+}
 // Searches for file in directory listing
 uint8_t find_file_in_dir(struct fat_fs_struct* fs, struct fat_dir_struct* dd, const char* name, struct fat_dir_entry_struct* dir_entry)

master/master/lib/serial.c

➞

Show inline comments

 /*
  * Master Firmware: USART Send/Recieve
+ *
  * Wireless Observational Modular Aerial Network
+ *
  * 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
 	/* Set baud rate */
 	UBRR0H = (unsigned char)(USART0_BAUD_PRESCALE>>8);
 	UBRR0L = (unsigned char)USART0_BAUD_PRESCALE;
 	UCSR0B |= (1 << RXCIE0); // Enable interrupt
 	//UCSR0A |= (1<<RXC0);
+}
 void serial1_setup() {
 //PROVEN in test project
 	/* Enable receiver and transmitter */
 	UCSR1B |= (1<<RXEN1)|(1<<TXEN1); // Enable rx/tx
 	/* Set frame format: 8data, 1stop bit */
 	UCSR1C |= (1 << UCSZ10) | (1 << UCSZ11); // - 1 stop bit
 	/* Set baud rate */
 	UBRR1H = (unsigned char)(USART1_BAUD_PRESCALE>>8);
 	UBRR1L = (unsigned char)USART1_BAUD_PRESCALE;
 	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);
 		stringPtr++;
+	}
+}
 void serial_sendCommand( char moduleID, char sensorID, char* data )
+{
 	char checkSum = 0x00; //initialize checksum
 	serial0_sendChar('['); //bracket indicates start of command
 	serial0_sendChar(moduleID);
 	checkSum+=moduleID;
 	serial0_sendChar(sensorID);
 	checkSum+=sensorID;
 	// send data, null-terminated
 	while(*data != 0x00)
+	{
 		serial0_sendChar(*data);
 		checkSum += *data;
 		data++;
+	}
 	serial0_sendChar(']'); //bracket indicates end of command
 	serial0_sendChar(checkSum); // checksum moved behind bracket to solve bug FS#29
+}
 void serial_sendResponseData()
+{
+}

master/master/lib/serial.h

➞

Show inline comments

 /*
  * Master Firmware: USART Send/Recieve
+ *
  * Wireless Observational Modular Aerial Network
+ *
  * Ethan Zonca
  * Matthew Kanning
  * Kyle Ripperger
  * Matthew Kroening
+ *
  */
 #ifndef SERIAL_H_
 #define SERIAL_H_
 #include <inttypes.h>
 #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

 /*
  * 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 <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;
+}
 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)
+	{
 		// We got some data, let's handle it
 		// ASCII payload
 		uint8_t len = getPayloadLength();
 		uint8_t* load = getPayload();
 		uint8_t type = getPayloadType();
 		// TODO: Check if type matches. if it doesn't, we have a problem...
 		uint16_t parsedVal = atoi(load);
 		if(slaves[currentSlave][currentSlaveSensor] == BOARDTEMP) {
 			sensordata_setBoardTemp(currentSlave, parsedVal);
+		}
 		else {
 			sensordata_set(slaves[currentSlave][currentSlaveSensor], parsedVal);
+		}
 		// If we finished all sensors for all slaves
 		if(slaves[currentSlave+1][0] == NONE && slaves[currentSlave][currentSlaveSensor+1] == NONE) // If next sensor is none and finished all slaves, reset
+		{
 			currentSlave = 0;
 			currentSlaveSensor = 0;
 			requesting = false;
+		}
 		// If we finished up one slave, go to the next
 		else if(slaves[currentSlave][currentSlaveSensor+1] == NONE)
+		{
 			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
+		{

master/master/lib/slavesensors.h

➞

Show inline comments

 /*
  * Master Firmware: Slave Sensor Data Aquisition
+ *
  * Wireless Observational Modular Aerial Network
+ *
  * Ethan Zonca
  * Matthew Kanning
  * Kyle Ripperger
  * Matthew Kroening
+ *
  */
 #ifndef SLAVESENSORS_H_
 #define SLAVESENSORS_H_
 #include <stdbool.h>
 #include <inttypes.h>
 // Serial Commands
 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

@@ @@ -13,164 +13,166 @@ @@
 #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/trackuinoGPS/gpsMKa.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)
+{
     _delay_ms(1500); // warmup
 	// 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
 	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;
 	// 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();
 			if(!afsk_busy())
 				serial1_ion();
 			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
 			//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)