seniordesign-firmware Changeset - 94648aa82312

Changeset - 94648aa82312

Parent rev.

Child rev.

[Not reviewed]

default

0 3 0

ethanzonca@CL-SEC241-08.cedarville.edu - 13 years ago 2012-11-15 15:50:20
ethanzonca@CL-SEC241-08.cedarville.edu

Cleanup of logger

3 files changed with 32 insertions and 29 deletions:

master/master/lib/logger.c

master/master/lib/sd/sd_raw.c

master/master/master.c

0 comments (0 inline, 0 general)

master/master/lib/logger.c

➞

Show inline comments

 /*
  * CFile1.c
+ *
  * Created: 11/7/2012 8:05:44 PM
  *  Author: mkanning
  */
 #include "../config.h"
 #include <util/delay.h>
 #include <string.h>
 #include <avr/pgmspace.h>
 #include <avr/sleep.h>
 #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 "../config.h"
 /*
 	//config edits
   * By changing the MCU* variables in the Makefile, you can use other Atmel
   * microcontrollers or different clock speeds. You might also want to change
   * the configuration defines in the files fat_config.h, partition_config.h,
   * sd_raw_config.h and sd-reader_config.h. For example, you could disable
   * write support completely if you only need read support.
  */
 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())
+	{
 		// initialization failed
 		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
 		// If the partition did not open, assume the storage device is a "superfloppy", i.e. has no MBR.
 		partition = partition_open(sd_raw_read, sd_raw_read_interval, sd_raw_write, sd_raw_write_interval, -1);
 		if(!partition)
+		{
 			// opening partition failed
 			return;
+		}
+	}
 	// Open FAT filesystem
 	fs = fat_open(partition);
 	if(!fs)
+	{
 		// opening filesystem failed
 		return;
+	}
 	// Open directory
 	fat_get_dir_entry_of_path(fs, "/", &directory);
 	dd = fat_open_dir(fs, &directory);
 	if(!dd)
+	{
 		// opening root directory failed
 		PORTA |= 0b00000101;
 		//PORTA |= 0b00000101;
 		_delay_ms(10);
 		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
 	// TODO: Catch errors here
 	fat_create_file(dd, filename, &directory);
 	eeprom_update_byte(LOGGER_ID_EEPROM_ADDR, logid);
 	/* search file in current directory and open it */
 	fd = open_file_in_dir(fs, dd, filename); //logger.h
 	// Search for file in current directory and open it
 	fd = open_file_in_dir(fs, dd, filename);
 	if(!fd)
+	{
 		PORTA |= 0b00000110;
 		_delay_ms(10);
 		//PORTA |= 0b00000110;
 		return;
+	}
 	int32_t offset = 0; //strtolong(offset_value);
 	if(!fat_seek_file(fd, &offset, FAT_SEEK_SET)) //seek to begin or end or what ??
 	// Seek to beginning of file
 	// TODO: Is this needed?
 	int32_t offset = 0;
 	if(!fat_seek_file(fd, &offset, FAT_SEEK_SET))
+	{
 		//error seek to file handling
 		PORTA |= 0b00000111;
 		// Error seeking to file
 		//PORTA |= 0b00000111;
 		_delay_ms(10);
 		fat_close_file(fd);
 		return;
+	}
 	// Write header information
 	logger_log(LOGGER_HEADERTEXT);
 	logger_log("\n-- BEGIN DATA --\n");
 	logger_log("C1, C2, C3, C4, C5, C6\n");
+}
 void logger_log(char *buffer) {
 	uint8_t len = strlen(buffer);
 	if(fat_write_file(fd, (uint8_t*) buffer, len) != len)
+	{
-		//uart_puts_p(PSTR("error writing to file\n"));
+		// Error writing to file
 		return;
+	}
+}
 void logger_closeLog() {
 	fat_close_file(fd); //may want to leave file open ??
 	/* close directory */
 	fat_close_dir(dd); //fat.c
 	/* close file system */
 	fat_close(fs); //fat.c
 	/* close partition */
 	partition_close(partition); //partition.c
 	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)
+{
 	while(fat_read_dir(dd, dir_entry))
+	{
 		if(strcmp(dir_entry->long_name, name) == 0)
+		{
 			fat_reset_dir(dd);
 			return 1;
+		}
+	}
 	return 0;
+}

master/master/lib/sd/sd_raw.c

➞

Show inline comments

@@ @@ -300,195 +300,195 @@ uint8_t sd_raw_init() @@
         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 */
     SPCR0 &= ~((1 << SPR10) | (1 << SPR00)); /* Clock Frequency: f_OSC / 4 */
     SPSR0 |= (1 << SPI2X0); /* 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 get_pin_available() == 0x00;
+}
 /**
  * \ingroup sd_raw
  * Checks wether 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 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)
+{
     SPDR0 = b;
     /* wait for byte to be shifted out */
     while(!(SPSR0 & (1 << SPIF0)));
     SPSR0 &= ~(1 << SPIF0);
+}
 /**
  * \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 */
     SPDR0 = 0xff;
 		PORTA = 0x01;
+		//PORTA = 0x01;
     while(!(SPSR0 & (1 << SPIF0)));
 	PORTA = 0x02;
+	//PORTA = 0x02;
     SPSR0 &= ~(1 << SPIF0);
     return SPDR0;
+}
 /**
  * \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;
     while(length > 0)
+    {
         /* determine byte count to read at once */
         block_offset = offset & 0x01ff;
         block_address = offset - block_offset;
         read_length = 512 - block_offset; /* read up to block border */
         if(read_length > length)
             read_length = length;
 #if !SD_RAW_SAVE_RAM
         /* check if the requested data is cached */
         if(block_address != raw_block_address)
 #endif
+        {
 #if SD_RAW_WRITE_BUFFERING
             if(!sd_raw_sync())
                 return 0;
 #endif
             /* address card */
             select_card();
             /* send single block request */
 #if SD_RAW_SDHC
             if(sd_raw_send_command(CMD_READ_SINGLE_BLOCK, (sd_raw_card_type & (1 << SD_RAW_SPEC_SDHC) ? block_address / 512 : block_address)))
 #else
             if(sd_raw_send_command(CMD_READ_SINGLE_BLOCK, block_address))
 #endif
+            {
                 unselect_card();
                 return 0;

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 "lib/serial.h"
 #include "lib/aprs.h"
 #include "lib/afsk.h"
 #include "lib/led.h"
 #include "lib/logger.h"
 #include "lib/sd/sd_raw_config.h"
 void micro_setup() {
 	// Generic microcontroller config options
+}
 int main(void)
+{
 	// Initialize
 	//micro_setup();
 	led_setup();
 	//serial_setup(); // Config serial ports
 	logger_setup(); // this takes a few ms
 	afsk_setup();
 	logger_setup(); // this takes a few ms
     while(1)
 	while(afsk_busy());
 	while(1)
+    {
 		logger_log("123,43,1,2,4,3\n");
 		//afsk_test();
 		// Wait for transmission to complete before starting another.
 		// Hopefully this will never delay because it should issue on a timed schedule. Software timers!
 		while(afsk_busy());
 		aprs_send();
         //serial_SendCommand('0','A',0,0);
+    }
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)