/trunk/code/lib/src/libdragonfly/i2c.c - Diff - Colony - Robotics Club

Revision 336

Updated wireless to use a circular buffer instead of a queue using malloc. Tested on both the computer and robots with a token ring, and was successful.

     /**
      * Copyright (c) 2007 Colony Project
+     *
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
      * files (the "Software"), to deal in the Software without
-...
      * copies of the Software, and to permit persons to whom the
      * Software is furnished to do so, subject to the following
      * conditions:
+     *
+     *
      * The above copyright notice and this permission notice shall be
      * included in all copies or substantial portions of the Software.
+     *
+     *
      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-...
     /**
      * @file i2c.c
      * @brief Implemenation of I2C communications protocol
+     *
+     *
      * In the case where you have master sends and then a master request to the same
      * address, you will not give up control of the line because the send and
      * request addresses are seen as different addresses. In between it will send a
-...
     #include "ring_buffer.h"
     /**
      * @defgroup i2c I2C
      * @defgroup i2c I2C
+     *
      * @brief Provides Inter-Interconnected-Communications (I2C)
+     *
      * Initiates I2C functions on an ATMega128 which has a fully hardware Two Wire
+     *
      * Initiates I2C functions on an ATMega128 which has a fully hardware Two Wire
      * Interface (TWI) module. Any Atmel chip with this hardware should be able to
      * use the software.
+     *
      * This code will operate in a multi-master enviornment and can be either a
      * slave or a master at any time (as long as they are not one or the other at
      * the moment. You can queue up multiple transmission modes in the buffer up to
      * the moment. You can queue up multiple transmission modes in the buffer up to
      * the buffer size. The buffer is implemented as a ring buffer.
+     *
      * It is implemented using callback functions. Whenever you want to send a packet
-...
      * so you must either buffer the inputs or handle each one separately.
+     *
      * On errors we will simply flush the entire buffer.
+     *
+     *
      * For information on how I2C operates, read the wikipedia article
      * http://en.wikipedia.org/wiki/I2c
      * for a good explanation of how it works.
      * @{
      */
     /**
     /**
      * @brief Set bit rate 12 = 100kbit/s (max speed setting is 10 for an
      *  8 MHz clock). It is a divider, so the lower the number the faster the speed.
      */
-...
      * are not set to null they will be called when that transmission mode is called. The address
      * is your address that you will listen to when you are not the master.
+     *
      * @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.
      * @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.
+     *
      * @return 0 for success, nonzero for failure
      **/
     int i2c_init(char addr, fun_mrecv_t master_recv, fun_srecv_t slave_recv, fun_send_t slave_send) {
       master_recv_function = master_recv;
       slave_recv_function = slave_recv;
       slave_send_function = slave_send;
         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);
         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));
       /* 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 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;
         /* 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;
+    }
     /**
-...
      * Will perform a send over I2C to the destination from data for the ammount of
      * bytes that bytes is.
+     *
      * @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.
      * @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.
+     *
      * @return zero for success, nonzero for failure
      **/
     int i2c_send(char dest, char *data, size_t bytes) {
       int i;
         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;
         /* 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);
+        }
         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;
         /* 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;
+    }
     /**
      * @brief Send a master request to the destination
+     *
-...
      * not work if the slave has not informationt to send or has nothing implemented
      * to send it.
+     *
      * @param dest    The destination that we want to receive information from.
      * @param dest		The destination that we want to receive information from.
+     *
      * @return 0 for success, nonzero for failure
      **/
      **/
     int i2c_request(char dest) {
       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;
         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;
+    }
     /** @} **/
     /**
      * @brief Interrupt to handle I2C interrupts from the I2C hardware.
+     *
+     *
      * Uses the status codes from the I2C register to handle the events
      * needed to advance in I2C stages. For instance, you will get a bit for
      * receiving a start ack, then a address ack, then a data ack, etc.
-...
      * of what modes the send is in.
+     *
      * Errors are handled here as well.
      **/
      **/
     ISR(TWI_vect) {
       static char data_to_send;
       static char addr_to_send = -1;
       char addr, statusCode;
     	static char data_to_send;
     	static char addr_to_send = -1;
     	char addr, statusCode;
     	//Get status code (only upper 5 bits)
     	statusCode = (TWSR & 0xF8);
       //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;
       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;
+          }
             //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);
+        }
         /* 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);
+      }
       /* Toggle TWINT so that it resets and executes the commands */
       TWCR |= _BV(TWINT);
+    }

Also available in: Unified diff

Project

General

Profile

Colony

Revision 336