/*

 * i2c.h

 *

 * Created: 11/7/2012 7:18:33 PM

 *  Author: kripperger

 */ 

#ifndef I2C_H_

#define I2C_H_

#if (__GNUC__ * 100 + __GNUC_MINOR__) < 304

#error "This library requires AVR-GCC 3.4 or later, update to newer AVR-GCC compiler !"

#endif

#include <avr/io.h>

/** defines the data direction (reading from I2C device) in i2c_start(),i2c_rep_start() */

#define I2C_READ    1

/** defines the data direction (writing to I2C device) in i2c_start(),i2c_rep_start() */

#define I2C_WRITE   0

void i2c_init(void);	//initialize the I2C master interace. Need to be called only once

void i2c_stop(void);	//Terminates the data transfer and releases the I2C bus

unsigned char i2c_start(unsigned char addr);	//Issues a start condition and sends address and transfer direction 

	//addr is the address and transfer direction of I2C device

	//Returns   0   device accessible 

	//Returns   1   failed to access device 

unsigned char i2c_rep_start(unsigned char addr);	//Issues a repeated start condition and sends address and transfer direction

	//addr is the address and transfer direction of I2C device

	//Returns   0   device accessible

	//Returns   1   failed to access device

void i2c_start_wait(unsigned char addr);	//Issues a start condition and sends address and transfer direction. If device is busy, use ack polling to wait until device ready 

	//addr is the address and transfer direction of I2C device

unsigned char i2c_writeX(unsigned char data);	//Send one byte to I2C device

	//data is the byte to be transfered

	//Returns   0   write successful

	//Returns   1   write failed

unsigned char i2c_readAck(void);	//read one byte from the I2C device, request more data from device

	//Returns byte read from I2C device

unsigned char i2c_readNak(void);	//read one byte from the I2C device, read is followed by a stop condition

	//Returns byte read from I2C device

unsigned char i2c_readX(unsigned char ack);	//read one byte from the I2C device. Implemented as a macro, which calls either i2c_readAck or i2c_readNak

#define i2c_readX(ack)  (ack) ? i2c_readAck() : i2c_readNak(); 

	//When ack is 1: send ack, request more data from device

	//When ack is 0: send nak, read is followed by a stop condition

	//Returns byte read from I2C device

void i2c_write(unsigned char addr, unsigned char reg, unsigned char data); //Does complete write. Can be used as stand alone function.

unsigned char i2c_read(unsigned char addr, unsigned char reg);

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

#endif /* I2C_H_ */

/*

 * masterComm.c

 *

 * Created: 1/22/2013 3:40:53 PM

 *  Author: kripperger

 */ 

#include <avr/io.h>

#include <stdio.h>

#include "../config.h"

#include "masterComm.h"

#include "serial.h"

#include "serparser.h"

#include "inputOutput.h"

#include "sensors.h"

#include "geiger.h"

#include "led.h"

uint8_t dataTypes;

char buff2[64];

char masterComm_checksum(const char* stringPtr)

{

	char sum = 0;

	while(*stringPtr != 0x00)

	{

		sum += *stringPtr;

		stringPtr++;

	}

	return sum;

}

void masterComm_types()

{

	switch(io_getModuleId())

	{

		case 0:

			// Generic

			dataTypes = DATATYPES_GENERIC;

			break;

		case 1:

			// Sensors

			dataTypes = DATATYPES_SENSOR;

			break;

		case 2:

			// Geiger

			dataTypes = DATATYPES_GEIGER;

			break;

		case 3:

			// Camera

			dataTypes = DATATYPES_CAMERA;

			break;

		default:

			dataTypes = DATATYPES_GENERIC;

			break;

	}

}

void masterComm_modules()

{

	// Send BoardTemperature (Common for all modules)

	serial0_sendChar('[');

	serial0_sendString(buff2);

	serial0_sendChar(']');	

	serial0_sendChar(masterComm_checksum(buff2));	

	// Send module specific sensor readings

	switch(io_getModuleId())

	{

		case 0:

			// Generic

			break;

		case 1:

			// Sensors

			// Send SPI Temperature (Air)

			serial0_sendChar('[');

			snprintf(buff2,64,"2%u",sensors_getSpiTemp());

			serial0_sendString(buff2);

			serial0_sendChar(']');

			serial0_sendChar(masterComm_checksum(buff2));

			// Send Ambient Light (Needs to be formatted)

			serial0_sendChar('[');

			snprintf(buff2,64,"3%u",geiger_getCpm());		//FIX

			serial0_sendString(buff2);

			serial0_sendChar(']');

			serial0_sendChar(masterComm_checksum(buff2));

/*			

			// Send CPM (radiation)

			serial0_sendChar('[');

			snprintf(buff2,64,"7%u",geiger_getCpm());

			serial0_sendString(buff2);

			serial0_sendChar(']');

			serial0_sendChar(masterComm_checksum(buff2));

			// Send CPM (radiation)

			serial0_sendChar('[');

			snprintf(buff2,64,"7%u",geiger_getCpm());

			serial0_sendString(buff2);

			serial0_sendChar(']');

			serial0_sendChar(masterComm_checksum(buff2));

			// Send CPM (radiation)

			serial0_sendChar('[');

			snprintf(buff2,64,"7%u",geiger_getCpm());

			serial0_sendString(buff2);

			serial0_sendChar(']');

			serial0_sendChar(masterComm_checksum(buff2));

*/

			break;

		case 2:

			// Geiger

			// Send CPM (radiation)

			serial0_sendChar('[');

			snprintf(buff2,64,"7%u",geiger_getCpm());

			serial0_sendString(buff2);

			serial0_sendChar(']');

			serial0_sendChar(masterComm_checksum(buff2));

			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

}

void masterComm_checkParser()

{

	if (serparser_parse() == PARSERESULT_PARSEOK)

	{

		if (getPayloadType() == ('@'-0x30))		// Request for data recieved

		{

			led_on(2);

			// Send all data

			masterComm_send();

			//led_off(2);

		}	

	}

}

/*

 * masterComm.h

 *

 * Created: 1/22/2013 3:40:43 PM

 *  Author: kripperger

 */ 

#ifndef MASTERCOMM_H_

#define MASTERCOMM_H_

char masterComm_checksum(const char* stringPtr);

void masterComm_types();	// Calculates the number of types the module has

void masterComm_modules();	// Sends sensor data depending on module

void masterComm_checkParser();	// Runs parser and checks for data request

void masterComm_send();		// Sends data after being requested

#endif /* MASTERCOMM_H_ */

/*

 * sensors.c

 *

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

 *  Author: kripperger

 */ 

#include <inttypes.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)

//Should these two be int16_t?  CHANGED TO INT32 BASED ON DATASHEET

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

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

uint16_t humid;		// Humidity (from i2c)

uint8_t light;		// Lux reading (from i2c)

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;

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(0xEE, 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(0xEE, 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

}

void sensors_readHumid()

{

	humid = i2c_read16(HUMID_ADDR);

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

{

	// FOR FIRST BYTE:

	light = i2c_read(LIGHT_ADDR, 0x03);

	// exponent = 8xE3 + 4xE2 + 2xE1 + E0

	// mantissa = 8xM7 + 4xM6 + 2xM5 + M4

	// light = 2^(exponent)*mantissa*0.72

	// FOR BOTH BYTES:

	// light = light << 4;

	// light = light | (0x0F & i2c_read(LIGHT_ADDR, 0x04));  //  This can be used to read in the 4 LSBs from the second register

	// exponent = 8xE3 + 4xE2 + 2xE1 + E0

	// mantissa = 128xM7 + 64xM6 + 32xM5 + 16xM4 + 8xM3 + 4xM2 + 2xM1 + M0

	// light = 2^(exponent)*mantissa*0.045

}

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;

}

{

	return humid;

}

uint8_t sensors_getLight(void)		// Gets light from variable

{

	return light;

}