#define F_CPU 11059200

#define MODULE_ID '1'

// --------------------------------------------------------------------------

// Error Codes config (led.c, used throughout code)

// --------------------------------------------------------------------------

// SD Card

#define ERROR_SD_INIT 2

#define ERROR_SD_PARTITION 3

// --------------------------------------------------------------------------

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

// Circular serial buffer size. Must be at least MAX_CMD_LEN + 5

#define BUFFER_SIZE 32 

// Public broadcast address

#define BROADCAST_ADDR 0 

// --------------------------------------------------------------------------

// USART config (serial.c)

// --------------------------------------------------------------------------

#define USART0_BAUDRATE 115200

// --------------------------------------------------------------------------

// AX.25 config (ax25.c)

// --------------------------------------------------------------------------

// TX delay in milliseconds

#define TX_DELAY      300

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

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

// APRS comment: this goes in the comment portion of the APRS message. You

// might want to keep this short. The longer the packet, the more vulnerable

// it is to noise.

// Transmit the APRS sentence every X milliseconds

// --------------------------------------------------------------------------

// Logger config (logger.c)

// --------------------------------------------------------------------------

#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 

#endif /* CONFIG_H_ */

// constants

#define MODEM_CLOCK_RATE F_CPU

#define PLAYBACK_RATE MODEM_CLOCK_RATE / 256  // Fast PWM

#define BAUD_RATE 1200

//#define SAMPLES_PER_BAUD PLAYBACK_RATE / BAUD_RATE // = 36

//#define SAMPLES_PER_BAUD 36

#define SAMPLES_PER_BAUD 36

// phase offset of 1800 gives ~1900 Hz

// phase offset of 3300 gives ~2200 Hz

#define PHASE_DELTA_1200 1800

// Module globals

volatile unsigned char current_byte;

volatile unsigned char current_sample_in_baud;    // 1 bit = SAMPLES_PER_BAUD samples

volatile bool go = false;                 

volatile unsigned int packet_pos;                 // Next bit to be sent out

volatile unsigned int afsk_packet_size = 10;

volatile const uint8_t *afsk_packet;

void afsk_ptt_off() 

	TCCR2B = (TCCR2B & ~(_BV(CS22) | _BV(CS21))) | _BV(CS20);

	// Enable interrupt when TCNT2 reaches TOP (0xFF) (p.151, 163)

	//TIMSK2 |= _BV(TOIE2);

	TIMSK2 |= 0b00000001;

	// FIXME TODO

	DDRD = 0xff;

	PORTD = 0xff;

	// todo: init radio, maybe in main

	while(afsk_busy());

}

 * Ethan Zonca

 * Matthew Kanning

 * Kyle Ripperger

 * Matthew Kroening

 *

 */

#include "../config.h"

#include "aprs.h"

#include "ax25.h"

#include <stdio.h>

float gps_altitude = 123.5;

int gps_course = 5;

int gps_speed = 13;

float meters_to_feet(float m)

{

  // 10000 ft = 3048 m

  return m / 0.3048;

}

void aprs_send()

{

	}

}

// Turn the specified LED on

void led_on(uint8_t led) 

{

	*(ledList[led].port) |= (1<<ledList[led].pin);

}

	// Turn the specified LED off

void led_off(uint8_t led) 

{

}

// Flashes error LED a set amount of times, then leaves it on

void led_errorcode(uint8_t code) 

{

	_delay_ms(400);

	for(int i=0; i<code; i++) 

	{

		led_on(LED_ERROR);

		_delay_ms(150);

		led_off(LED_ERROR);

		_delay_ms(150);

enum leds {

	LED_ACT0 = 0,

	LED_ACT1,

	LED_ACT2,

	LED_ACT3,

	LED_POWER,

	LED_STATUS,

	LED_ERROR,

	LED_SIDEBOARD,

	LED_ACTIVITY,

};

typedef struct {uint8_t* direction; uint8_t* port; uint8_t pin;} led_t;

// Match order of leds enum

static led_t ledList[] = {

//pcb:

//breadboard:

	{&DDRD, &PORTD, PD6}, // SIDEBOARD

	{&DDRD, &PORTD, PD5}, // ACTIVITY

	{&DDRD, &PORTD, PD4}, // CYCLE

};

void led_setup();

void led_on(uint8_t led);

void led_off(uint8_t led);

void led_errorcode(uint8_t code);

#endif /* 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!

		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)

	{

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

		return;

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

}

	/* Set baud rate */

	UBRR1H = (unsigned char)(USART1_BAUD_PRESCALE>>8);

	UBRR1L = (unsigned char)USART1_BAUD_PRESCALE;

}

void serial0_sendChar( unsigned char byte )

{

	while (!(UCSR0A & (1<<UDRE0)));

	UDR0 = byte;

}

void serial1_sendChar( unsigned char byte )

{

	while (!(UCSR1A & (1<<UDRE1)));

	UDR1 = byte;

}

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

#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);

void serial_sendCommand( char moduleID, char sensorID, char* data );

void serial_sendResponseData();

#endif /* SERIAL_H_ */

		payloadLength = 0;

		checksumCalc = 0;

	}

	// Every time we change state, we have parsed a byte

	bufferParsePosition = (bufferParsePosition + 1) % BUFFER_SIZE;

}

// Receive data on USART

char debugBuff[16];

{

	buffer[bufferDataPosition % BUFFER_SIZE] = UDR0;

	bufferDataPosition = (bufferDataPosition + 1) % BUFFER_SIZE;

}

//#define DEBUG

// Parse data from circular buffer

int serparser_parse(void)

{

	char byte;

	// Process first command (if any) on the circular buffer

	while(bufferDataPosition != bufferParsePosition)

	{

		byte = buffer[bufferParsePosition];

/*

* gpsMKa.c

*

* Created: 11/15/2012 12:02:38 PM

*  Author: mkanning

*/

#include <stdbool.h>

#include <avr/io.h>

#include "gpsMKa.h"

#include "../serial.h"

// holds the byte ALREADY PARSED. includes starting character

int bytesReceived = 0;

//data (and checksum) of most recent transmission

char data[16];

//used to skip over bytes during parse

int skipBytes = 0;

//used to index data arrays during data collection

int numBytes = 0;

	//RMC data fields

	RMC_TIME,

	RMC_VALIDITY,

	RMC_LATITUDE,

	RMC_LONGITUDE,

	RMC_KNOTS,

	RMC_COURSE,

	RMC_DATE,

	RMC_MAG_VARIATION,

}decodeState;

//// MKa GPS transmission parser START

void parse_gps_transmission(void){

	// Pull byte off of the buffer

	if(byte == '$') //start of transmission sentence

	{

		decodeState = GET_TYPE;

		numBytes = 0; //prep for next phases

		skipBytes = 0;

		calculatedChecksum = 0;

	}

	//parse transmission type

	else if (decodeState == GET_TYPE)

	{

#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

	sei();

}

// ISR for watchdog timeout. Not currently used, interrupt is disabled.

ISR(WDT_vect)

{

}

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

#include "lib/sd/sd_raw_config.h"

#include "lib/looptime.h"

#include "lib/slavesensors.h"

#include "lib/serparser.h"

#include "lib/sensordata.h"

void micro_setup() 

{

}

int main(void)

{

	// Initialize libraries

	time_setup();

	micro_setup();

	led_setup();

	serial0_setup();

	serial1_setup();

	sensordata_setup(); // must happen before sensors/logger/afsk

	slavesensors_setup();

	logger_setup();

	afsk_setup();

	led_on(LED_POWER);

	// Buffer for string operations

	char logbuf[16];

	// Software timers	

	uint32_t lastAprsBroadcast = 0;

	uint32_t lastLog = 0;

	// Result of last parser run

	int parseResult = PARSERESULT_NODATA;

	// Write CSV header to SD card

	//logger_log("ProgramTime,LastAprsBroadcast,LastLog\n");

	while(1)

    {

		// Periodic: Logging

		if(time_millis() - lastLog > LOGGER_RATE) 

		{

			led_on(LED_STATUS);

			snprintf(logbuf, 16, "%lu,%d,\r\n", time_millis(), sensordata_get(HUMIDITY));

			logger_log(logbuf);

			led_off(LED_STATUS);

			lastLog = time_millis();

		}		

		// Periodic: APRS transmission

		if(time_millis() - lastAprsBroadcast > APRS_TRANSMIT_PERIOD) 

		{

			while(afsk_busy());

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

		wdt_reset();

    }

}