/*

 * led.c

 *

 * Created: 10/25/2012 3:34:03 PM

 *  Author: ethanzonca

 */ 

#include <avr/io.h>

void led_setup() {

	// Configure ports/pins for LEDs

	DDRA = 0xff;

}

void led_on(uint8_t led) {

	// Turn the specified LED on

	PORTA |= (1<<led);

}

void led_off(uint8_t led) {

	// Turn the specified LED off

	PORTA &= ~(1<<led);

}

void led_toggle(uint8_t led) {

	// Toggle the specified LED 

}

/*

 * 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"

/* 

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

		_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

	fat_create_file(dd, filename, &directory);

	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)

	{

		_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

		_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)

	{

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

{

	while(fat_read_dir(dd, dir_entry))

	{

		if(strcmp(dir_entry->long_name, name) == 0)

		{

			fat_reset_dir(dd);

			return 1;

		}

	}

	return 0;

}

static uint8_t sd_raw_send_command(uint8_t command, uint32_t arg);

/**

 * \ingroup sd_raw

 * Initializes memory card communication.

 *

 * \returns 0 on failure, 1 on success.

 */

uint8_t sd_raw_init()

{

    /* enable inputs for reading card status */

    configure_pin_available();

    configure_pin_locked();

    /* enable outputs for MOSI, SCK, SS, input for MISO */

    configure_pin_mosi();

    configure_pin_sck();

    configure_pin_ss();

    configure_pin_miso();

    unselect_card();

    // initialize SPI with lowest frequency; max. 400kHz during identification mode of card

    SPCR0 = (0 << SPIE0) | // SPI Interrupt Enable 

            (1 << SPE0)  | // SPI Enable 

            (0 << DORD0) | // Data Order: MSB first 

            (1 << MSTR0) | // Master mode 

            (0 << CPOL0) | // Clock Polarity: SCK low when idle 

            (0 << CPHA0) | // Clock Phase: sample on rising SCK edge 

            (1 << SPR10);   // Clock Frequency: f_OSC / 128 

            //(1 << SPR00); // commentnig this out means /64, which gives over 100khz as required

    SPSR0 &= ~(1 << SPI2X0); // No doubled clock frequency 

/*

	while(1) {

		SPDR0 = 'a';					//Load byte to Data register

		while(!(SPSR0 & (1<<SPIF0))); 	// Wait for transmission complete

	}

*/

    /* initialization procedure */

    sd_raw_card_type = 0;

    if(!sd_raw_available())

        return 0;

    /* card needs 74 cycles minimum to start up */

    for(uint8_t i = 0; i < 10; ++i)

    {

        /* wait 8 clock cycles */

        sd_raw_rec_byte();

    }

    /* address card */

    select_card();

    /* reset card */

    uint8_t response;

    for(uint16_t i = 0; ; ++i)

    {

        response = sd_raw_send_command(CMD_GO_IDLE_STATE, 0);

        if(response == (1 << R1_IDLE_STATE))

            break;

        if(i == 0x1ff)

        {

            unselect_card();

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

    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

 *

 * \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;

    while(!(SPSR0 & (1 << SPIF0)));

    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;

            }

            /* wait for data block (start byte 0xfe) */

            while(sd_raw_rec_byte() != 0xfe);

#if SD_RAW_SAVE_RAM

            /* read byte block */

            uint16_t read_to = block_offset + read_length;

            for(uint16_t i = 0; i < 512; ++i)

            {

                uint8_t b = sd_raw_rec_byte();

                if(i >= block_offset && i < read_to)

                    *buffer++ = b;

            }

#else

            /* read byte block */

            uint8_t* cache = raw_block;

            for(uint16_t i = 0; i < 512; ++i)

                *cache++ = sd_raw_rec_byte();

            raw_block_address = block_address;

            memcpy(buffer, raw_block + block_offset, read_length);

            buffer += read_length;

#endif

            /* read crc16 */

            sd_raw_rec_byte();

            sd_raw_rec_byte();

            /* deaddress card */

            unselect_card();

            /* let card some time to finish */

            sd_raw_rec_byte();

        }

#if !SD_RAW_SAVE_RAM

        else

        {

            /* use cached data */

            memcpy(buffer, raw_block + block_offset, read_length);

            buffer += read_length;

        }

#endif

        length -= read_length;

        offset += read_length;

    }

    return 1;

}

/**

 * \ingroup sd_raw

 * Continuously reads units of \c interval bytes and calls a callback function.

 *

 * This function starts reading at the specified offset. Every \c interval bytes,

 * it calls the callback function with the associated data buffer.

 *

 * By returning zero, the callback may stop reading.

 *

 * \note Within the callback function, you can not start another read or

 *       write operation.

 * \note This function only works if the following conditions are met:

 *       - (offset - (offset % 512)) % interval == 0

 *       - length % interval == 0

 *

 * \param[in] offset Offset from which to start reading.

 * \param[in] buffer Pointer to a buffer which is at least interval bytes in size.

 * \param[in] interval Number of bytes to read before calling the callback function.

 * \param[in] length Number of bytes to read altogether.

 * \param[in] callback The function to call every interval bytes.

 * \param[in] p An opaque pointer directly passed to the callback function.

 * \returns 0 on failure, 1 on success

 * \see sd_raw_write_interval, sd_raw_read, sd_raw_write

 */

uint8_t sd_raw_read_interval(offset_t offset, uint8_t* buffer, uintptr_t interval, uintptr_t length, sd_raw_read_interval_handler_t callback, void* p)

{

    if(!buffer || interval == 0 || length < interval || !callback)

        return 0;

#if !SD_RAW_SAVE_RAM

    while(length >= interval)

    {

        /* as reading is now buffered, we directly

         * hand over the request to sd_raw_read()

         */

        if(!sd_raw_read(offset, buffer, interval))

            return 0;

        if(!callback(buffer, offset, p))

            break;

        offset += interval;

        length -= interval;

    }

    return 1;

#else

/*

 * watchdog.c

 *

 * Created: 11/19/2012 6:50:51 PM

 *  Author: ethanzonca

 */ 

#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 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 "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/sd/sd_raw_config.h"

void micro_setup() {

}

int main(void)

{

	// Initialize. If this takes more than 4 seconds, be sure to reset the WDT

	micro_setup();

	watchdog_setup();

	led_setup();

	serial_setup(); // Config serial ports

	logger_setup(); // this takes a few ms

	afsk_setup(); // can take a few ms

	uint16_t ctr1 = 0;

	uint16_t ctr2 = 255;

	char logbuf[32];

	while(1)

    {

		led_on(STAT);

		logger_log(logbuf);

		led_off(STAT);

		// 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(); // non-blocking

		ctr1++;

		ctr2-=6;

		wdt_reset();

    }

}

<?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>ATmega324P</avrdevice>

    <avrdeviceseries>none</avrdeviceseries>

    <OutputType>Executable</OutputType>

    <Language>C</Language>