#ifndef CONFIG_H_

#define CONFIG_H_

#define F_CPU 11059200

#define MODULE_ID '1'

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

// Error Codes config (led.c)

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

// SD Card

#define ERROR_SD_INIT 2

#define ERROR_SD_PARTITION 3

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

// Slave Sensors config (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

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

// USART config (serial.c)

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

#define USART0_BAUDRATE 115200

#define USART1_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_ID   11

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

#define APRS_TRANSMIT_PERIOD 5000

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

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

 */

#include "../config.h"

#include <stdint.h>

#include <stdbool.h>

#include <avr/io.h>

#include <avr/interrupt.h> 

#include <util/delay.h>

#include <avr/pgmspace.h>

PROGMEM extern const uint8_t afsk_sine_table[512] = {

  127, 129, 130, 132, 133, 135, 136, 138, 139, 141, 143, 144, 146, 147, 149, 150, 152, 153, 155, 156, 158, 

  159, 161, 163, 164, 166, 167, 168, 170, 171, 173, 174, 176, 177, 179, 180, 182, 183, 184, 186, 187, 188, 

// phase offset of 1800 gives ~1900 Hz

// phase offset of 3300 gives ~2200 Hz

#define PHASE_DELTA_1200 1800

#define PHASE_DELTA_2200 2200

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

	// turn ptt off

}

	// turn the ptt on... possibly delay based on spec

}

ISR(TIMER2_OVF_vect) 

{

	if (go) {

		// If done sending packet

			go = false;         // End of transmission

			afsk_timer_stop();  // Disable modem

			afsk_ptt_off();    // Release PTT

			return; // done

		}

		// If sent SAMPLES_PER_BAUD already, go to the next bit

				current_byte = afsk_packet[packet_pos >> 3];

			}				

				current_byte = current_byte / 2;  // ">>1" forces int conversion

			}			

				// Toggle tone (1200 <> 2200)

				phasedelta ^= (PHASE_DELTA_1200 ^ PHASE_DELTA_2200);

			}

		}

		phase += phasedelta;

		uint8_t s = afsk_read_sample((phase >> 7) & (TABLE_SIZE - 1));

		afsk_output_sample(s);

			current_sample_in_baud = 0;

			packet_pos++;

		}

	}

}	

	OCR2B = s;

}

void afsk_timer_start()

{

	// Clear the overflow flag, so that the interrupt doesn't go off

	// immediately and overrun the next one (p.163).

	TIFR2 |= _BV(TOV2);       // Yeah, writing a 1 clears the flag.

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

	TIMSK2 |= _BV(TOIE2);

}

int afsk_busy()

{

	return go;

}

void afsk_send(const uint8_t *buffer, int len)

{

	afsk_packet_size = len;

	afsk_packet = buffer;

}

	// Source timer2 from clkIO (datasheet p.164)

	ASSR &= ~(_BV(EXCLK) | _BV(AS2));

	// Set fast PWM mode with TOP = 0xff: WGM22:0 = 3  (p.150)

	TCCR2A |= _BV(WGM21) | _BV(WGM20);

	TCCR2B &= ~_BV(WGM22);

	// Do non-inverting PWM on pin OC2B (arduino pin 3) (p.159).

	// OC2A (arduino pin 11) stays in normal port operation:

	// COM2B1=1, COM2B0=0, COM2A1=0, COM2A0=0

	TCCR2A = (TCCR2A | _BV(COM2B1)) & ~(_BV(COM2B0) | _BV(COM2A1) | _BV(COM2A0));

#ifndef AFSK_H_

#define AFSK_H_

// Private

void afsk_output_sample(uint8_t s);

void afsk_timer_stop();

// Public

void afsk_setup();

void afsk_test();

void afsk_send(const uint8_t *buffer, int len);

int afsk_busy();

void afsk_start();

#endif /* AFSK_H_ */

#include "../config.h"

#include "aprs.h"

#include "ax25.h"

#include <stdio.h>

const char *gps_aprs_lat = "omgmylatitude";

const char *gps_aprs_lon = "omgmylongitude";

const char *gps_time = "omgmygpstime";

float gps_altitude = 123.5;

int gps_course = 5;

int gps_speed = 13;

#ifndef APRS_H_

#define APRS_H_

void aprs_send();

#endif /* APRS_H_ */

#include <inttypes.h>

#include "../config.h"

#include "ax25.h"

#include "afsk.h"

// Module globals

static uint16_t crc;

static uint8_t ones_in_a_row;

static uint8_t packet[MAX_PACKET_LEN];

static unsigned int packet_size;

// Module functions

void update_crc(uint8_t a_bit)

{

	crc ^= a_bit;

	if (crc & 1)

	crc = (crc >> 1) ^ 0x8408;  // X-modem CRC poly

	else

	crc = crc >> 1;

}

void send_byte(uint8_t a_byte)

{

	uint8_t i = 0;

		uint8_t a_bit = a_byte & 1;

		a_byte >>= 1;

		update_crc(a_bit);

			// Next bit is a '1'

			if (packet_size >= MAX_PACKET_LEN * 8)  // Prevent buffer overrun

			return;

			packet[packet_size >> 3] |= (1 << (packet_size & 7));

			packet_size++;

			if (++ones_in_a_row < 5) continue;

		}

		// Next bit is a '0' or a zero padding after 5 ones in a row

		if (packet_size >= MAX_PACKET_LEN * 8)    // Prevent buffer overrun

		return;

		packet[packet_size >> 3] &= ~(1 << (packet_size & 7));

		packet_size++;

// Exported functions

void ax25_send_byte(uint8_t a_byte)

{

	// Wrap around send_byte, but prints debug info

	send_byte(a_byte);

}

void ax25_send_flag()

{

	uint8_t flag = 0x7e;

	int i;

		if (packet_size >= MAX_PACKET_LEN * 8)  // Prevent buffer overrun

		return;

		if ((flag >> i) & 1)

		packet[packet_size >> 3] |= (1 << (packet_size & 7));

		else

		packet[packet_size >> 3] &= ~(1 << (packet_size & 7));

	}

}

void ax25_send_string(const char *string)

{

	int i;

		ax25_send_byte(string[i]);

	}

}

void ax25_send_header(const struct s_address *addresses, int num_addresses)

{

	int i, j;

	packet_size = 0;

	ones_in_a_row = 0;

	crc = 0xffff;

	// Send flags during TX_DELAY milliseconds (8 bit-flag = 8000/1200 ms)

		ax25_send_flag();

	}

		// Transmit callsign

		for (j = 0; addresses[i].callsign[j]; j++)

		send_byte(addresses[i].callsign[j] << 1);

		// Transmit pad

		for ( ; j < 6; j++)

		send_byte(' ' << 1);

		// Transmit SSID. Termination signaled with last bit = 1

		if (i == num_addresses - 1)

		send_byte(('0' + addresses[i].ssid) << 1 | 1);

		else

		send_byte(('0' + addresses[i].ssid) << 1);

	}

#ifndef AX25_H_

#define AX25_H_

#include <inttypes.h>

struct s_address {

	char callsign[7];

	unsigned char ssid;

};

#include "../config.h"

#include <avr/io.h>

#include <util/delay.h>

#include "led.h"

void led_setup() 

{

	// Configure ports/pins for LEDs

	DDRA = 0xff;

	//PORTA = 0x00;

}

#ifndef LED_H_

#define LED_H_

#define POWER PB2

#define ERROR PB1

#define STAT PB0

#define OK 2

void led_setup();

void led_on(uint8_t led);

#include "../config.h"

#include <util/delay.h>

#include <string.h>

#include <stdio.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"

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

}	

	uint8_t len = strlen(buffer);

	if(fat_write_file(fd, (uint8_t*) buffer, len) != len)

	{

		// Error writing to file

		return;

	}

}

	fat_close_file(fd);

	fat_close_dir(dd);

	fat_close(fs);

	partition_close(partition);

}

// INTERNAL FUNCTIONS

#ifndef LOGGER_H_

#define LOGGER_H_

void logger_setup();

uint8_t logger_writeLine(char* dateLine, uint8_t length);

struct fat_file_struct* open_file_in_dir(struct fat_fs_struct* fs, struct fat_dir_struct* dd, const char* name);

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

void logger_log(char *buffer);

void logger_closeLog();

#include "../config.h"

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

volatile uint32_t millis = 0; // Milliseconds since initialization

	DDRA = 0xff;

	// Generic microcontroller config options

	OCR0A = 173; // Approx 172.7969 ticks per ms with 64 prescaler

	TCCR0A |= (1 << WGM01) | (1 << WGM00); // Count until OCR0A, then overflow (wgm02 in the next line specifies this as well)

	TCCR0B |= (1 << CS01) | (1 << CS00) | (1 << WGM02); // clock div by 64

	TIFR0 |= ( 1 << TOV0 ); // clear pending interrupts

	TIMSK0 |= (1 << TOIE0); // enable overflow interrupt

}

	millis = millis + 1;

}

	return millis; // meh accuracy, but that's OK

}