Colony

 * @param addr 			Your address on the I2C bus.

 * @param master_recv 	The address of the function to call when you receive a byte when you are a

 *                    	master.

 * @param slave_recv 	The address of the function to call when you are a slave you receive data

 *								from the master

 * @param slave_send		The address of the function to call when you are a slave and the master

 *								requests data from you.

    master_recv_function = master_recv;

    slave_recv_function = slave_recv;

    slave_send_function = slave_send;

    RING_BUFFER_CLEAR(i2c_write_buff);

    RING_BUFFER_CLEAR(i2c_addr_buff);

    /* enables twi interrupt, automatic ack sending, and all twi hardware */

    TWCR =  (_BV(TWEA) | _BV(TWEN) | _BV(TWIE));

    /* sets the bit rate of data transmission */

    TWBR = I2C_BIT_RATE_DIVIDER;

    /* sets the address (it is stored in the 7 most significant bits) and allows

     * global messages to be accepted */

    TWAR = (addr << 1) | 1;

    return 0;

 * @param dest		Destination address of the data on the I2C bus.

 * @param data 	The pointer to the byte array of data

 * @param bytes	The amount of bytes long that the byte array is. This is how

 *						many bytes from the array that the function will send.

    int i;

    /* adding data to be sent to ring buffers is not atomic,

     * so disable interrupts */

    cli();

    for(i = 0; i < bytes; i++) {

        if(RING_BUFFER_FULL(i2c_write_buff)) {

            sei();

            return -1;

        }

        RING_BUFFER_ADD(i2c_write_buff, data[i]);

        RING_BUFFER_ADD(i2c_addr_buff, dest << 1);

    /* re-enable the interrupts */

    sei();

    /* send the start bit, only if this device is not currently master */

    if(!start_flag) {

        start_flag = 1;

        TWCR |= _BV(TWSTA);

        TWCR |= _BV(TWINT);

    }

    return 0;

 * @param dest		The destination that we want to receive information from.

    if(RING_BUFFER_FULL(i2c_write_buff))

        return -1;

    RING_BUFFER_ADD(i2c_write_buff, 0);

    RING_BUFFER_ADD(i2c_addr_buff, (dest << 1) | 1);

    if(!start_flag) {

        start_flag = 1;

        TWCR |= _BV(TWSTA);

        TWCR |= _BV(TWINT);

    }

    return 0;

	static char data_to_send;

	static char addr_to_send = -1;

	char addr, statusCode;

	//Get status code (only upper 5 bits)

	statusCode = (TWSR & 0xF8);

    switch (statusCode) {

        //Start sent successfully

        case TW_START:

        case TW_REP_START:

            /* Send address and write

             * ring_buffer will not be empty */

            RING_BUFFER_REMOVE(i2c_addr_buff, addr_to_send);

            RING_BUFFER_REMOVE(i2c_write_buff, data_to_send);

            /* first send the address */

            TWDR = addr_to_send;

            //Turn off start bits

            TWCR &= ~_BV(TWSTA);

            break;

        //Master Transmit - Address sent succesfully

        case TW_MT_SLA_ACK:

        //Send byte

            TWDR = data_to_send;

            PORTG &= ~_BV(PG2);

            break;

        //Master Transmit - Data sent succesfully

        case TW_MT_DATA_ACK:

            //If there is still data to send

            if(!RING_BUFFER_EMPTY(i2c_write_buff)) {

                RING_BUFFER_PEEK(i2c_addr_buff, addr);

                //Still data for this address

                if (addr == addr_to_send) {

                    RING_BUFFER_REMOVE(i2c_addr_buff, addr);

                    RING_BUFFER_REMOVE(i2c_write_buff, TWDR);

                    break;

                //No more data for this address, data for another address -> resend start

                } else {

                    TWCR |= _BV(TWSTA);

                    break;

                }

            }

            /* there are no bytes to send */

            TWCR |= _BV(TWSTO);

            start_flag = 0;

            break;

        //Master Transmit - Slave sends a nack, transmit is done

        case TW_MT_DATA_NACK:

            PORTG |= _BV(PG2);

            TWCR |= _BV(TWSTO);

            start_flag = 0;

            break;

        //Master Receive - Address sent succesfully

        case TW_MR_SLA_ACK:

            PORTG |= _BV(PG2);

            break;

        //Master Receive - Data received succesfully

        case TW_MR_DATA_ACK:

            if(master_recv_function) {

                if(!master_recv_function(TWDR)) {

                    TWCR &= ~_BV(TWEA);

                }

            }

            break;

        //Master Receive - Slave sends a nack, transmission is done

        case TW_MR_DATA_NACK:

            TWCR |= _BV(TWEA);

            //If there is still data to send

            if(!RING_BUFFER_EMPTY(i2c_write_buff)) {

                TWCR |= _BV(TWSTA);

                break;

            }

            /* there are no bytes to send */

            TWCR |= _BV(TWSTO);

            start_flag = 0;

            break;

        //Slave Transmit - Address received

        case TW_ST_SLA_ACK:

            break;

        //Slave Transmit - Nack received, no data requsted

        case TW_ST_DATA_NACK:

            break;

        //Slave Transmit - Data requested, ack received

        case TW_ST_DATA_ACK:

            if (slave_send_function) {

                TWDR = slave_send_function();

            }

            break;

        //Slave Receive - Address received

        case TW_SR_SLA_ACK:

            break;

        //Slave Receive - Data received, ack returned

        case TW_SR_DATA_ACK:

            if(slave_recv_function) {

                slave_recv_function(TWDR);

            }

            break;

        //Stop sent

        case TW_SR_STOP:

            break;

        //Problem on the bus, reset everything

        default:

            TWCR |= _BV(TWSTO);

            start_flag = 0;

            RING_BUFFER_CLEAR(i2c_write_buff);

            RING_BUFFER_CLEAR(i2c_addr_buff);

    }