/*

 * geiger.c

 *

 * Created: 11/19/2012 9:24:05 PM

 *  Author: kripperger

 */ 

#include <inttypes.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include "../config.h"

#include <util/delay.h>

#include "geiger.h"

volatile uint8_t seconds;		// Counts Seconds from Timer2 interrupt

volatile uint16_t counts;		// Counts the pulses

volatile uint16_t cpm;			// Counts per minuite

ISR(TIMER2_OVF_vect)    // Timer 2 overflow interrupt handler

{

	// This executes every second.  Update real-time clocks.

	// Used only in Geiger module

	seconds++;

	if (seconds>=30)

	{

		cpm = (counts*2);

		seconds = 0;

		counts = 0;

	}

}

ISR(PCINT0_vect)    // Interrupt on PA0

{

	// Interrupts when pulse received from Geiger tube

	counts++;	// Increment counter.

}

uint16_t geiger_getCpm()

{

	return cpm;

}

uint8_t geiger_getCount()	//DEBUG

{

	return counts;

}

void geiger_on()

{

	// Turn the Flyback Transformer on

	PORTA |= (1 << PA1);	//ON

}

void geiger_refresh()

{

	// Turn the Flyback Transformer off

	PORTA &= ~(1 << PA1);	//OFF

	_delay_ms(1);

	// Turn the Flyback Transformer on

	PORTA |= (1 << PA1);	//ON

}

/*

 * io.c

 *

 * Created: 11/7/2012 7:17:52 PM

 *  Author: kripperger

 */ 

#include <avr/io.h>

#include "../config.h"

#include "inputOutput.h"

#include "led.h"

#include "sensors.h"

int8_t	moduleID;	// Slave Module ID from rotary dip switch (or EEPROM)

 void io_configure()

 {

	// Configure ports/pins

	DDRB |= (1 << DDB4);		// Set PB4 to Output for Heater (also allows SCK (on SPI bus) to operate)

	DDRC &= ~(1 << DDC2);		// Set PC2 to input for rotary dip

	DDRC &= ~(1 << DDC3);		// Set PC3 to input for rotary dip

	DDRC &= ~(1 << DDC4);		// Set PC4 to input for rotary dip

	DDRC &= ~(1 << DDC5);		// Set PC5 to input for rotary dip

	DDRA &= ~(1 << DDA7);		// Set PA7 to input for battery voltage divider

	//ADC register configurations for battery level detection on PA7

	ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);	// Set prescaler for ADC, 128 gives ADC freq of 125 KHz

	ADMUX |= (1 << REFS0);									// Set ADC reference voltage to AVCC

	//ADMUX |= (1 << ADLAR);								// Sets 10 bit ADC to 8 bit

	ADMUX |= (1 << MUX2) | (1 << MUX1) | (1 << MUX0);		// Select ADC7 as the conversion channel

	ADCSRA |= (1 << ADATE);									// Enables auto trigger, determined in ADCSRB bits ADTS

	//ADCSRA |= (1 << ADIF);								// 

	//ADCSRA |= (1 << ADIE);								// ADC interrupt enable set

	ADCSRB &= ~((1 << ADTS2) | (1 << ADTS1) | (1 << ADTS0));// Set ADC auto trigger source to free running mode

	ADCSRA |= (1 << ADEN);									// Enable ADC

	ADCSRA |= (1 << ADSC);									// Start ADC measurements.  ADC should now continuously run conversions, which are stored in ADCH 0x79

 }

 void io_readModuleId()

 {

	// Get ID from rotary dip and return it. 

	/*

	// This method is temporary as the next release will read the module ID from EEPROM

	PORTC |= (1 << PC2);	// Pull pins on rotary dip high

	PORTC |= (1 << PC3);	// Pull pins on rotary dip high

	PORTC |= (1 << PC4);	// Pull pins on rotary dip high

	PORTC |= (1 << PC5);	// Pull pins on rotary dip high

	moduleID = ((PINC & 0b00011100) >> 2);		// Read Dip Encoder

	moduleID = ~moduleID;						//Invert Dip reading

	moduleID = (moduleID & 0b0111);				//Mask bits

	*/

	while(moduleID==0)           //UNCOMMENT ALL THIS

	{

		moduleID = i2c_read(EEPROM_ADDR, 0x05);

	}

 }

 uint8_t io_getModuleId()

 {

	return moduleID;

 }

 void io_heaterOn()

 {		

	PORTB |= (1 << PB4);	//ON

 }

 void io_heaterOff()

 {

	PORTB &= ~(1 << PB4);	//OFF

 }

 uint8_t io_heaterStatus()

 {

	 uint8_t state;

	 state = 0;

	 state = ((PORTB & 0b00010000) >> 4);

	 return state;

 }

  void io_regulateTemp()

  {

	}

}

void masterComm_packetSend_unsigned(uint8_t id, uint32_t data)

{

	serial0_sendChar('[');

	snprintf(buff2,64,"%u%lu",id,data);

	serial0_sendString(buff2);

	serial0_sendChar(']');

	serial0_sendChar(masterComm_checksum(buff2));

}

void masterComm_packetSend_signed(uint8_t id, int32_t data)

{

	serial0_sendChar('[');

	snprintf(buff2,64,"%u%ld",id,data);

	serial0_sendString(buff2);

	serial0_sendChar(']');

	serial0_sendChar(masterComm_checksum(buff2));

}

void masterComm_modules()

{

	// Send Board Temperature (Common for all modules)

	masterComm_packetSend_signed(0,sensors_getBoardTemp());

	// Send Heater Status (Common for all modules)

	masterComm_packetSend_unsigned(1,io_heaterStatus());

	// Send Battery Level (Common for all modules)

	masterComm_packetSend_unsigned(2,sensors_getBatt());

	// Send module specific sensor readings

	switch(io_getModuleId())

	{

		case 0:

			// Generic

			break;

		case 1:

			// Sensors

			// Send SPI Temperature (Air)

			// Send Ambient Light (Needs to be formatted)

			masterComm_packetSend_unsigned(4,sensors_getLux());

			// Send Humidity

			masterComm_packetSend_unsigned(5,/*Humidity Get Function Here */999);		

			// Send Pressure 

			masterComm_packetSend_unsigned(6,sensors_getPressure());			

			// Send Altitude

			masterComm_packetSend_unsigned(7,sensors_getAltitude());

			break;

		case 2:

			// Geiger

			// Send CPM (radiation)

			masterComm_packetSend_unsigned(8,geiger_getCpm());

			break;

		case 3:

			// Camera

			break;

		default:

			break;

	}

}

void masterComm_send()

{

	masterComm_types();		// Calculates how many data types to send

	// Return request with number of data types to be sent

	serial0_sendChar('[');						// Send opening bracket

	snprintf(buff2,64,"@%u",dataTypes);				// Send package (@ reply and number of data types)

	serial0_sendString(buff2);

	serial0_sendChar(']');						// Send closing bracket

	serial0_sendChar(masterComm_checksum(buff2));	// Calculate and send checksum

	masterComm_modules();	// Send sensor data

}

/*

 * watchdog.c

 *

 * Created: 3/12/2013 3:58:20 PM

 *  Author: kripperger

 */ 

#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

	sei();

}

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

ISR(WDT_vect)

{

}

/*

 * modules.c

 *

 * Created: 11/9/2012 11:44:22 AM

 *  Author: kripperger

 */ 

 #include <inttypes.h>

 #include <avr/io.h>

 #include <avr/interrupt.h>

 #include "config.h"

 #include <util/delay.h>

 #include "modules.h"

 #include "lib/spi.h"

 #include "lib/i2c.h"

 #include "lib/sensors.h"

 #include "lib/loopTimer.h"

 #include "lib/led.h"

 uint32_t lastPicture;

 void modules_setup(uint8_t id)

 {

	switch(id)

	{

		case 0:

			modules_generic_setup();

			break;

		case 1:

			modules_sensors_setup();

			break;

		case 2:

			modules_geiger_setup();

			break;

		case 3:

			modules_cameras_setup();

			break;

		default:

			modules_generic_setup();

			break;

	}

 }

 void modules_run(uint8_t id)

 {

	switch(id)

	{

		case 0:

			modules_generic();

			break;

		case 1:

			modules_sensors();

			break;

		case 2:

			modules_geiger();

			break;

		case 3:

			modules_cameras();

			break;

		default:

			modules_generic();

			break;

	}

 }

 void modules_generic_setup()

 {

 }

 void modules_sensors_setup()

 {

	DESELECT_TEMP;

	setup_spi();

	sensors_setupPressure();

 }

 void modules_geiger_setup()

 {

	// Pin setup

	// Setup for interrupt input on PA0 (PCINT0)

	// Setup for interrupt from Timer2

	ASSR &= ~(1 << EXCLK);	// Disable external clock input (enabling crystal use)

	ASSR |= (1 << AS2);		// Enable timer2 async mode with an external crystal	

	_delay_ms(100);			// Let external 32KHz crystal stabilize

	TCCR2B = 0x05;			// Set the prescaler to 128: 32.768kHz / 128 = 1Hz overflow

	TIFR2 = 0x01;			// Reset timer2 overflow interrupt flag

	TIMSK2 = 0x01;			// Enable interrupt on overflow

 }

 void modules_cameras_setup()

 {

	 lastPicture = time_millis();	 

	 DDRA |= (1 << DDA0);	// Set PA0 to Output for Camera

	 DDRA |= (1 << DDA1);	// Set PA1 to Output for Camera

	 DDRA |= (1 << DDA2);	// Set PA2 to Output for Camera

	 DDRA |= (1 << DDA3);	// Set PA3 to Output for Camera

 }

 void modules_generic()

 {

	// Gathers data and performs functions for generic daughter board

 }

 void modules_sensors()

 {

	// Gathers data and performs functions for sensor daughter board

	sensors_readBoardTemp();		//Data Read

	sensors_readSpiTemp();			//Data Read	

	sensors_readPressure();			//Data Read

	//sensors_readHumid();			//Data Read

	//sensors_readLux();				//Data Read

 }

 void modules_geiger()

 {

	// No data gatering function needed for geiger daughter board

		// This is taken care of in interrupt (See geiger.c)

		//lastRefresh = time_millis();

		//if ((time_millis() - lastRefresh) > 1000000)

/*

 * Slave Firmware

 *

 * Wireless Observational Modular Aerial Network

 *

 * Kyle Ripperger

 * Ethan Zonca

 * Matthew Kanning

 * Matthew Kroening

 *

 */

#include "config.h"

#include <stdio.h>

#include <stdbool.h>

#include <inttypes.h>

#include <avr/io.h>

#include <compat/twi.h>

#include <util/delay.h>

#include <avr/cpufunc.h>

#include <avr/interrupt.h>

#include <avr/wdt.h>

#include "modules.h"

#include "lib/serial.h"

#include "lib/serparser.h"

#include "lib/led.h"

#include "lib/inputOutput.h"

#include "lib/i2c.h"

#include "lib/spi.h"

#include "lib/geiger.h"

#include "lib/sensors.h"

#include "lib/cameras.h"

#include "lib/loopTimer.h"

#include "lib/masterComm.h"

#include "lib/watchdog.h"

bool WDTreset = false;

void micro_setup()

{

	// Generic microcontroller config options

	WDTreset = ((MCUSR & 0b00001000) > 0);	// Check if WDT reset occured

	MCUSR = 0;		// Clear reset flags

	wdt_disable();	// Disable WDT

	_delay_ms(50);	// Power debounce

	sei();			// Enable interrupts

}

int main(void)

{

	// Initialize	

	micro_setup();			// Generic microcontroller config options

	time_setup();			// Setup loop timer and interrupts (TIMER0)

	led_configure();		// Configure ports and registers for LED operation

	io_configure();			// Configure IO ports and registers

	i2c_init();				// Setup I2C

	serial0_setup();		// Config serial port 0

	serial1_setup();		// Config serial port 1

	_delay_ms(50);	// Setup hold delay

	if(WDTreset) led_on(1);	// Turn on LED if WDT reset has occurred	

	io_readModuleId();

	modules_setup(io_getModuleId());	// Run setup functions for specific module

	uint32_t lastLoop = 0;	// Time in ms when last loop occurred 

	// Serial output //DEBUG

	char buff[128];						//Buffer for serial output //DEBUG

	serial1_sendString("Starting Slave\r\n");	//DEBUG

    while(1)

    {	

		wdt_reset();	// Resets WDT (to prevent restart)

		// Master communication

		masterComm_checkParser();	//Checks parser for data requests from master

		// Main slave operations

		if ((time_millis() - lastLoop) > SENSOR_LOOP)	// Uses program timer to run every so often. Time interval defined in config.h

		{

			led_on(0);

			sensors_readBatt();				// Read Battery level

			sensors_readBoardTemp();		// Read board temperature sensor (Common on all slaves) (Data Read)

			modules_run(io_getModuleId());	// Runs specific module functions (like data reading)

			io_regulateTemp();			// Gets board temperature and enables heater if below threshold

			snprintf(buff,128,"|ModuleID: %u |BoardTemp: %i |Millis: %lu |Lux: %lu |Press: %lu |Altitude: %lu |Batt: %u |spiTemp: %i |Humidity: %u \r\n ",io_getModuleId(),sensors_getBoardTemp(),time_millis(),sensors_getLux(),sensors_getPressure(),sensors_getAltitude(),sensors_getBatt(),sensors_getSpiTemp(),sensors_getHumid()); //DEBUG

			serial1_sendString(buff); //DEBUG

			led_off(0);

			lastLoop = time_millis();

// Writes ID to EEPROM, change for all modules and delete after programming

// 0 is for generic setup,	 1 is for sensors,	 2 is for Geiger,	3 is for cameras

//i2c_write(EEPROM_ADDR, 0x05, 0x02);			

		}	// IFloop