/*

 * config.h

 *

 * Created: 10/25/2012 10:00:09 PM

 *  Author: mkanning

 */

 #ifndef CONFIG_H_

 #define CONFIG_H_

 #define F_CPU 11059200				// Clock frequency (used in calculations)

//Serial

#define USART0_BAUDRATE 115200

#define USART1_BAUDRATE 115200 

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

#define BUFFER_SIZE 32

// Maximum payload size of command

#define MAX_PAYLOAD_LEN 16

// Number of datatypes to transmit per module type

#define DATATYPES_GENERIC 3

#define DATATYPES_SENSOR 8

#define DATATYPES_GEIGER 4

#define DATATYPES_CAMERA 3

//Sensors and IO

#define SENSOR_LOOP 200				// Frequency of sensor reads (in ms) (should be 200)

#define HEATER_THRESHOLD 0			// Temperature threshold in Fahrenheit where heater is activated

#define CAMERA_FREQ 30000		// Camera pulse frequency (Should be 30000 for 30 Secs)

 //I2C Addresses

 #define EEPROM_ADDR 0xA0		// Read 0xA1 - Write 0xA0

 #define BOARDTEMP_ADDR 0x90	// Read 0x91 - Write 0x90

 #define PRESSURE_ADDR 0xEE		// Read 0xEF - Write 0xEE

 #define HUMID_ADDR 0x27		// Read 0x28 - Write 0x27

 #define LIGHT_ADDR 0x94		// Read 0x95 - Write 0x94

 #define ACCEL_ADDR	0x38		// Read 0x39 - Write 0x38

 #define RTC_ADDR 0xB2			//DEBUG [Used for testing]      // Read 0xA3 - Write 0xA2

 #endif /* CONFIG_H_ */

 Return:  0 device accessible

          1 failed to access device

*************************************************************************/

unsigned char i2c_rep_start(unsigned char address)

{

    return i2c_start( address );

}/* i2c_rep_start */

/*************************************************************************

 Terminates the data transfer and releases the I2C bus

*************************************************************************/

void i2c_stop(void)

{

    /* send stop condition */

	TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);

	// wait until stop condition is executed and bus released

//	startTime = time_millis();

	while(TWCR & (1<<TWSTO));

	{

//		if ((time_millis() - startTime) > 10)

//		{

//			break;	// Timeout Reached!

//		}

	}

}/* i2c_stop */

/*************************************************************************

  Send one byte to I2C device

  Input:    byte to be transfered

  Return:   0 write successful 

            1 write failed

*************************************************************************/

unsigned char i2c_writeX( unsigned char data )

{	

    uint8_t   twst;

	// send data to the previously addressed device

	TWDR = data;

	TWCR = (1<<TWINT) | (1<<TWEN);

	// wait until transmission completed

	//startTime = time_millis();

	while(!(TWCR & (1<<TWINT)));

	//{

		//if ((time_millis() - startTime) > 10)

		//{

			//break;	// Timeout Reached!

		//}

	//}

	// check value of TWI Status Register. Mask prescaler bits

	twst = TW_STATUS & 0xF8;

	if( twst != TW_MT_DATA_ACK) return 1;

	return 0;

}/* i2c_write */

/*************************************************************************

 Read one byte from the I2C device, request more data from device 

 Return:  byte read from I2C device

*************************************************************************/

unsigned char i2c_readAck(void)

{

	TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA);

	//startTime = time_millis();

	while(!(TWCR & (1<<TWINT)));

	//{

		//if ((time_millis() - startTime) > 10)

		//{

			//break;	// Timeout Reached!

		//}

	//}  

    return TWDR;

}/* i2c_readAck */

/*************************************************************************

 Read one byte from the I2C device, read is followed by a stop condition 

 Return:  byte read from I2C device

*************************************************************************/

unsigned char i2c_readNak(void)

{

	TWCR = (1<<TWINT) | (1<<TWEN);

	//startTime = time_millis();

	while(!(TWCR & (1<<TWINT)));

	//{

		//if ((time_millis() - startTime) > 10)

		//{

			//break;	// Timeout Reached!

		//}

	//}

    return TWDR;

}/* i2c_readNak */

/*************************************************************************

 Write one byte to the I2C device, read is followed by a stop condition 

 Return:  void

*************************************************************************/

void i2c_write(unsigned char addr, unsigned char reg, unsigned char data)

{

	i2c_start_wait(addr+I2C_WRITE);     // set device address and write mode

	i2c_writeX(reg);                    // write register address

	i2c_writeX(data);                   // write value data to register

	i2c_stop();                         // set stop condition = release bus

}/* i2c_write */

/*************************************************************************

 Read one byte from the I2C device, read is followed by a stop condition 

 Return:  byte read from I2C device

*************************************************************************/

uint8_t i2c_read(unsigned char addr, unsigned char reg)

{

	uint8_t   data;

	i2c_start_wait(addr+I2C_WRITE);		// set device address and write mode

	i2c_writeX(reg);						// write register address

	i2c_rep_start(addr+I2C_READ);   // set device address and read mode

	data = i2c_readNak();               // read one byte

	i2c_stop();

    return data;

}/* i2c_read */

///////////added for humidity

uint16_t i2c_read16(unsigned char addr)

{

	uint16_t   data;

	uint8_t   dataL;

	i2c_start_wait(addr+I2C_WRITE);		// set device address and write mode

	i2c_rep_start(addr+I2C_READ);   // set device address and read mode

	data = i2c_readAck();               // read one byte

	dataL = i2c_readNak();

	i2c_stop();

	data = data << 8;

	data = data | dataL;

	return data;

}/* i2c_read16 */

uint16_t i2c_humidRead()

{

	uint16_t   data;

	uint8_t   dataL;

	//i2c_start_wait(HUMID_ADDR+I2C_WRITE);	// set device address and write mode

	//i2c_rep_start(HUMID_ADDR+I2C_READ);   // set device address and read mode

	i2c_start(HUMID_ADDR+I2C_WRITE);	// Measurement Request

	i2c_stop();					// Stop

	i2c_start(HUMID_ADDR+I2C_READ);		// Measurement Request	

	data = i2c_readAck();               // read one byte

	dataL = i2c_readNak();

	i2c_stop();

	data = data | dataL;

	return data;

}

/*

 * sensors.c

 *

 * Created: 11/19/2012 9:25:01 PM

 *  Author: kripperger

 */ 

#include <inttypes.h>

#include <math.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include "../config.h"

#include <util/delay.h>

#include "sensors.h"

#include "spi.h"

#include "i2c.h"

int16_t	spiTemp;	// Thermocouple Temperature (from spi)

int8_t	boardTemp;	// Board Temperature (from i2c)

int32_t ut;			// Temperature from BMP085 (from i2c)

int32_t up;			// Pressure from BMP085 (from i2c)

uint16_t humid;		// Humidity (from i2c)

uint8_t lightH;		// Higher byte from light sensor (from i2c)

uint8_t lightL;		// Lower byte from light sensor

uint8_t exponent;	// Exponent for Lux

uint8_t mantissa;	// Mantissa for Lux

uint32_t lux;		// Calculated Lux value

uint8_t battL;		// Low byte of ADC

uint16_t batt;		// Read battery voltage from ADC

uint16_t vBatt;		// battery voltage

int16_t ac1;		// The following 11 variables are the calibration values for the BMP085

int16_t ac2;

int16_t ac3;

uint16_t ac4;

uint16_t ac5;

uint16_t ac6;

int16_t b1;

int16_t b2;

int16_t mb;

int16_t mc;

int16_t md;

int32_t x1;			// The following variables are needed to calculate the true pressure

int32_t x2;

int32_t x3;

int32_t b3;

uint32_t b4;

int32_t b5;

int32_t b6;

uint32_t b7;

int32_t trueTemp;

int32_t pressure;

uint32_t altitude;

void sensors_setupPressure()

{

	//This function reads in the calibration values from the BMP085.  This is done only once.

	ac1 = i2c_read(PRESSURE_ADDR, 0xAA);

	ac1 = ac1 << 8;

	ac1 = ac1 | i2c_read(PRESSURE_ADDR, 0xAB);

	ac2 = i2c_read(PRESSURE_ADDR, 0xAC);

	ac2 = ac2 << 8;

	ac2 = ac2 | i2c_read(PRESSURE_ADDR, 0xAD);

	ac3 = i2c_read(PRESSURE_ADDR, 0xAE);

	ac3 = ac3 << 8;

	ac3 = ac3 | i2c_read(PRESSURE_ADDR, 0xAF);

	ac4 = i2c_read(PRESSURE_ADDR, 0xB0);

	ac4 = ac4 << 8;

	ac4 = ac4 | i2c_read(PRESSURE_ADDR, 0xB1);

	ac5 = i2c_read(PRESSURE_ADDR, 0xB2);

	ac5 = ac5 << 8;

	ac5 = ac5 | i2c_read(PRESSURE_ADDR, 0xB3);

	ac6 = i2c_read(PRESSURE_ADDR, 0xB4);

	ac6 = ac6 << 8;

	ac6 = ac6 | i2c_read(PRESSURE_ADDR, 0xB5);

	b1 = i2c_read(PRESSURE_ADDR, 0xB6);

	b1 = b1 << 8;

	b1 = b1 | i2c_read(PRESSURE_ADDR, 0xB7);

	b2 = i2c_read(PRESSURE_ADDR, 0xB8);

	b2 = b2 << 8;

	b2 = b2 | i2c_read(PRESSURE_ADDR, 0xB9);

	mb = i2c_read(PRESSURE_ADDR, 0xBA);

	mb = mb << 8;

	mb = mb | i2c_read(PRESSURE_ADDR, 0xBB);

	mc = i2c_read(PRESSURE_ADDR, 0xBC);

	mc = mc << 8;

	mc = mc | i2c_read(PRESSURE_ADDR, 0xBD);

	md = i2c_read(PRESSURE_ADDR, 0xBE);

	md = md << 8;

	md = md | i2c_read(PRESSURE_ADDR, 0xBF);

}

void sensors_readSpiTemp()

{

	// Select TEMP wait 100 microseconds then read four bytes

	SELECT_TEMP;

	_delay_us(100);

	uint8_t one = send_spi(0xFF);

	_delay_us(100);

	uint8_t two = send_spi(0xFF);

	_delay_us(100);

	uint8_t three = send_spi(0xFF);

	_delay_us(100);

	uint8_t four = send_spi(0xFF);

	DESELECT_TEMP;

	int16_t temperature = ((one<<4)|(two>>4));	// Shift and place into larger int. (Cuts off Decimal)

	temperature = (temperature & (0x0800)) ? (temperature & 0xF000) : temperature;	// Sign extend

	//int16_t temperature = ((one<<6)|(two>>2));	// Shift and place into larger int. (Includes Decimal)

	//temperature = (temperature & (0x2000)) ? (temperature & 0xC000) : temperature;	// Sign extend

	temperature = (two & 0x01) ? 0x00DE : temperature;	// Error Condition. If error is detected output is set to 222 degrees (0x00DE)

	// Note: Temperature still needs to be scaled in order to be accurate (eg. boil water). Do this before implementing.

	spiTemp = temperature;

}

void sensors_readBoardTemp()

{

	boardTemp = i2c_read(BOARDTEMP_ADDR, 0x00);		// Read only the first byte of data (we don't need the resolution here)

	boardTemp = ((boardTemp*18)/10) + (32);			// Converting Celsius to Fahrenheit

	boardTemp = boardTemp - 3;						// Linear offset

}

void sensors_readPressure()

{

	i2c_write(PRESSURE_ADDR, 0xF4, 0x2E);				//write 0x2E (temp) into 0xF4 (control register), (write is 0xEE)

	_delay_us(4500);							//wait 4.5 ms

	ut = i2c_read(PRESSURE_ADDR, 0xF6);

	ut = ut << 8;

	ut = ut | i2c_read(PRESSURE_ADDR, 0xF7);	//ut = MSB<<8 + LSB

	i2c_write(PRESSURE_ADDR, 0xF4, 0x34);				//write 0x34 (pressure) into 0xF4 (control register), (write is 0xEE)

	_delay_us(4500);							//wait 4.5 ms

	up = i2c_read(PRESSURE_ADDR, 0xF6);

	up = up << 8;

	up = up | i2c_read(PRESSURE_ADDR, 0xF7);	//up = (MSB<<16 + LSB<<8 + XLSB(NOT USED)) >> (8-oss)

	//calculate true temperature

	x1 = ((ut - ac6) * ac5) >> 15;

	x2 = (mc << 11) / (x1 + md);

	b5 = x1 + x2;

	trueTemp = (b5 + 8) >> 4;

	//calculate b3

	b6 = b5 - 4000;

	x1 = (b2 * (b6 * b6) >> 12) >> 11;

	x2 = (ac2 * b6) >> 11;

	x3 = x1 + x2;

	b3 = ((ac1 * 4 + x3) + 2) / 4;

	//calculate b4

	x1 = (ac3 * b6) >> 16;

	x2 = (b1 * ((b6 * b6) >> 12)) >> 16;

	x3 = ((x1 + x2) + 2) >> 2;

	b4 = (ac4 * (x3 + 32768)) >> 15;

	b7 = (up - b3) * 50000;

	if (b7 < 0x80000000)

	{

		pressure = (b7 << 1) / b4;

	}

	else

	{

		pressure = (b7 / b4) << 1;

	}

	x1 = (pressure >> 8) * (pressure >> 8);

	x1 = (x1 * 3038) >> 16;

	x2 = (-7357 * pressure) >> 16;

	pressure += (x1 + x2 + 3791) >> 4;				//This is the final value for our pressure

	altitude = altitude * 3.2804;	//THIS IS IN FEET

}

void sensors_readHumid()

{

	//i2c_write(HUMID_ADDR, 0x00, 0x00);		//Measurement Request

	//humid = i2c_read16(HUMID_ADDR);

	humid = i2c_humidRead();

	//calculations to relative humidity: humid = (humid/((2^14) - 1))*100%       >> is divide by power, << is multiply by power, 2^14-1 = 16383

	 //humid = (humid / 16383) * 100;

}

void sensors_readLux()

{

	lightH = i2c_read(LIGHT_ADDR, 0x03);

	lightL = i2c_read(LIGHT_ADDR, 0x04);

	exponent = lightH;

	exponent = exponent >> 4;

	lightH = lightH << 4;

	mantissa = lightH | lightL;

	lux = (float)(pow(2,exponent) * mantissa) * 0.045;

}

void sensors_readBatt()

{

	battL = ADCL;					// Read low battery byte from ADC (all 8 bits)

	batt = ADCH;					// Read high battery byte from ADC (only two LSBs)

	batt = batt << 8;

	batt |= battL;

	vBatt = (batt * 10.0) / 67.4;

}

int16_t sensors_getSpiTemp(void)	// Gets spi temperature from variable

{

	return spiTemp;

}

int8_t sensors_getBoardTemp(void)	// Gets board temperature from variable

{

	return boardTemp;

}

int32_t sensors_getPressure(void)	// Gets pressure from variable

{

	return pressure;

}

uint16_t sensors_getHumid(void)			// Gets relative humidity from variable

{

	return humid;

}

uint32_t sensors_getLux(void)		// Gets light from variable

{

	return lux;

}

uint16_t sensors_getBatt(void)		// Gets battery voltage from variable

{

	return vBatt;

}

uint32_t sensors_getAltitude(void)

{

	return altitude;

}