/*

 * i2c.c

 *

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

 *  Author: kripperger

 */ 

#include <inttypes.h>

#include <compat/twi.h>

#include "../config.h"

#include "i2c.h"

/* I2C clock in Hz */

#define SCL_CLOCK  100000L

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

 Initialization of the I2C bus interface. Need to be called only once

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

void i2c_init(void)

{

  /* initialize TWI clock: 100 kHz clock, TWPS = 0 => prescaler = 1 */

  TWSR = 0;                         /* no prescaler */

  TWBR = ((F_CPU/SCL_CLOCK)-16)/2;  /* must be > 10 for stable operation */

}/* i2c_init */

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

  Issues a start condition and sends address and transfer direction.

  return 0 = device accessible, 1= failed to access device

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

unsigned char i2c_start(unsigned char address)

{

    uint8_t   twst;

	// send START condition

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

	// wait until transmission completed

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

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

	twst = TW_STATUS & 0xF8;

	if ( (twst != TW_START) && (twst != TW_REP_START)) return 1;

	// send device address

	TWDR = address;

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

	// wail until transmission completed and ACK/NACK has been received

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

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

	twst = TW_STATUS & 0xF8;

	if ( (twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK) ) return 1;

	return 0;

}/* i2c_start */

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

 Issues a start condition and sends address and transfer direction.

 If device is busy, use ack polling to wait until device is ready

 Input:   address and transfer direction of I2C device

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

void i2c_start_wait(unsigned char address)

{

    uint8_t   twst;

    while ( 1 )

    {

	    // send START condition

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

    	// wait until transmission completed

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

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

    	twst = TW_STATUS & 0xF8;

    	if ( (twst != TW_START) && (twst != TW_REP_START)) continue;

    	// send device address

    	TWDR = address;

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

    	// wail until transmission completed

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

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

    	twst = TW_STATUS & 0xF8;

    	if ( (twst == TW_MT_SLA_NACK )||(twst ==TW_MR_DATA_NACK) ) 

    	{    	    

    	    /* device busy, send stop condition to terminate write operation */

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

	        // wait until stop condition is executed and bus released

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

    	    continue;

    	}

    	//if( twst != TW_MT_SLA_ACK) return 1;

    	break;

     }

}/* i2c_start_wait */

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

 Issues a repeated start condition and sends address and transfer direction 

 Input:   address and transfer direction of I2C device

 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

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

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

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

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

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

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

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

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

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

uint8_t light;		// Lux reading (from i2c)

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

}

void sensors_readHumid()

{

}

void sensors_readLight()

{

	light = i2c_read(LIGHT_ADDR, 0x03);

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

	// FOR FIRST BYTE:

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

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

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

	// FOR BOTH BYTES:

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

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

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

}

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

{

	return spiTemp;

}

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

{

	return boardTemp;

}

{

}

{

	return light;

}

/*

 * sensors.h

 *

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

 *  Author: kripperger

 */ 

#ifndef SENSORS_H_

#define SENSORS_H_

void sensors_readSpiTemp(void);		// Reads spi temperature

void sensors_readBoardTemp(void);	// Reads board temperature

void sensors_readPressure(void);	// Reads pressure

void sensors_readHumid(void);		// Reads humidity

void sensors_readLight(void);		// Reads lux

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

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

uint8_t sensors_getLight(void);		// Gets lux from variable

#endif /* SENSORS_H_ */

/*

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

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

 {

 }

 void modules_geiger_setup()

 {

	// Pin setup

	DDRA &= ~(1 << DDA0);	// PA0 is an input

	// Setup for interrupt input on PA0 (PCINT0)

	PCMSK0 |= (1 << PCINT0);	// Enable interrupt for PA0

	PCICR |= (1 << PCIE0);		// Enable ioc section PCIF0

	// 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(250);			// 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

	sei();					// Enable all interrupts

 }

 void modules_cameras_setup()

 {

 }

 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