WebSVN - NaviCtrl - Diff - Rev 469 and 470

 // + #### END OF LICENSING TERMS ####
 // + Note: For information on license extensions (e.g. commercial use), please contact us at info(@)hisystems.de.
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 #include <string.h>
 #include "91x_lib.h"
-#include "i2c.h"
+#include "i2c1.h"
 #include "uart1.h"
 #include "timer1.h"
 #include "config.h"
 #include "led.h"
-volatile u8 I2C_State = I2C_STATE_OFF;          // only one byte, because of sync by nesting irqs
+volatile u8 I2C1_State = I2C_STATE_OFF;          // only one byte, because of sync by nesting irqs
-volatile u8 I2C_Error = I2C_ERROR_NOACK;    // only one byte!
+volatile u8 I2C1_Error = I2C_ERROR_NOACK;    // only one byte!
 // number of bytes to send
-volatile u8 I2C_TxBufferSize;
+volatile u8 I2C1_TxBufferSize;
 // number of bytes to receive
-volatile u8 I2C_RxBufferSize;
+volatile u8 I2C1_RxBufferSize;
 // the transfer buffer
-volatile u8 I2C_Buffer[I2C_BUFFER_LEN];
+volatile u8 I2C1_Buffer[I2C1_BUFFER_LEN];
 // the transfer direction
-volatile u8 I2C_Direction;
+volatile u8 I2C1_Direction;
 // the slave address
-volatile u8 I2C_SlaveAddress = 0x00;
+volatile u8 I2C1_SlaveAddress = 0x00;
 // function pointer to process the received bytes
-I2C_pRxHandler_t I2C_pRxHandler = NULL;
+I2C_pRxHandler_t I2C1_pRxHandler = NULL;
 // goblal timeout
 volatile u32 I2C1_Timeout = 0;
 //--------------------------------------------------------------
 void I2C1_Init(void)
+{
         I2C_InitTypeDef   I2C_Struct;
         GPIO_InitTypeDef  GPIO_InitStructure;
         I2C_Struct.I2C_CLKSpeed = I2C1_CLOCK;
         I2C_Struct.I2C_OwnAddress = 0x00;
         I2C_Init(I2C1, &I2C_Struct);
         // empty rx and tx buffer counters
-        I2C_TxBufferSize = 0;
+        I2C1_TxBufferSize = 0;
-        I2C_RxBufferSize = 0;
+        I2C1_RxBufferSize = 0;
         I2C_Cmd(I2C1, ENABLE);
         I2C_ITConfig(I2C1, ENABLE);
         VIC_Config(I2C1_ITLine, VIC_IRQ , PRIORITY_I2C1);
         I2C1_Timeout = SetDelay(10*I2C1_TIMEOUT);
         I2C_GenerateSTOP(I2C1, ENABLE);
-        I2C_State = I2C_STATE_IDLE;
+        I2C1_State = I2C_STATE_IDLE;
         // start some dummy transmissions cycles
         // to get the irq routine to work
         for(i=0;i<10;i++)
+        {
-                I2C_State = I2C_STATE_BUFFBUSY;
+                I2C1_State = I2C_STATE_BUFFBUSY;
-                I2C_Transmission(0,1,0,1);
+                I2C1_Transmission(0,1,0,1);
         GPIO_InitTypeDef  GPIO_InitStructure;
         UART1_PutString("\r\n I2C1 deinit...");
         I2C_GenerateStart(I2C1, DISABLE);
         I2C_GenerateSTOP(I2C1, ENABLE);
         VIC_ITCmd(I2C1_ITLine, DISABLE);
-        I2C_State = I2C_STATE_OFF;
+        I2C1_State = I2C_STATE_OFF;
         I2C_ITConfig(I2C1, DISABLE);
         I2C_Cmd(I2C1, DISABLE);
         I2C_DeInit(I2C1);
         SCU_APBPeriphClockConfig(__I2C1, DISABLE);
         GPIO_InitStructure.GPIO_IPInputConnected =      GPIO_IPInputConnected_Disable;
         GPIO_InitStructure.GPIO_Alternate =     GPIO_InputAlt1;
         GPIO_Init(GPIO2, &GPIO_InitStructure);
         // empty rx and tx buffer
-        I2C_TxBufferSize = 0;
+        I2C1_TxBufferSize = 0;
-        I2C_RxBufferSize = 0;
+        I2C1_RxBufferSize = 0;
         I2C1_Timeout = SetDelay(10*I2C1_TIMEOUT);
                 while(I2C_GetFlagStatus (I2C1, I2C_FLAG_BTF) != RESET)
+                {
                         I2C_GenerateSTOP (I2C1, ENABLE);  // free the bus
                         I2C_GenerateSTOP (I2C1, DISABLE); // free the bus
+                }
-                I2C_State = I2C_STATE_IDLE;
+                I2C1_State = I2C_STATE_IDLE;
-                I2C_Error = I2C_ERROR_NOACK;
+                I2C1_Error = I2C_ERROR_NOACK;
                 VIC_ITCmd(I2C1_ITLine, DISABLE);
                 return;
+        }
         else
         {       // depending on current i2c state
+                {
                         // the start condition was initiated on the bus
                         case I2C_EVENT_MASTER_MODE_SELECT:
                                 // update current bus state variable
                                 // jump to rx state if there is nothing to send
-                                switch(I2C_Direction)
+                                switch(I2C1_Direction)
+                                {
                                         case I2C_MODE_TRANSMITTER:
-                                                I2C_State = I2C_STATE_TX_PROGRESS;
+                                                I2C1_State = I2C_STATE_TX_PROGRESS;
                                                 break;
                                         case I2C_MODE_RECEIVER:
-                                                if (I2C_RxBufferSize == 0) // nothing to send?
+                                                if (I2C1_RxBufferSize == 0) // nothing to send?
+                                                {
                                                         I2C_GenerateSTOP (I2C1, ENABLE);
                                                         VIC_ITCmd(I2C1_ITLine, DISABLE);
-                                                        I2C_State = I2C_STATE_IDLE;
+                                                        I2C1_State = I2C_STATE_IDLE;
-                                                        I2C_Error = I2C_ERROR_NONE;
+                                                        I2C1_Error = I2C_ERROR_NONE;
                                                         return;
+                                                }
                                                 else
                                                 {
-                                                        I2C_State = I2C_STATE_RX_PROGRESS;
+                                                        I2C1_State = I2C_STATE_RX_PROGRESS;
+                                                }
                                                 break;
                                         default: // invalid direction
                                                 I2C_GenerateSTOP (I2C1, ENABLE);
                                                 VIC_ITCmd(I2C1_ITLine, DISABLE);
-                                                I2C_State = I2C_STATE_IDLE;
+                                                I2C1_State = I2C_STATE_IDLE;
-                                                I2C_Error = I2C_ERROR_UNKNOWN;
+                                                I2C1_Error = I2C_ERROR_UNKNOWN;
                                                 return;
+                                }
                                 // enable acknowledge
                                 I2C_AcknowledgeConfig (I2C1, ENABLE);
                                 // send address/direction byte on the bus
-                                I2C_Send7bitAddress(I2C1, I2C_SlaveAddress, I2C_Direction);
+                                I2C_Send7bitAddress(I2C1, I2C1_SlaveAddress, I2C1_Direction);
                                 break;
                         // the address byte was send
                         case I2C_EVENT_MASTER_MODE_SELECTED:
                                 // Clear EV6 by set again the PE bit
                                 I2C_Cmd(I2C1, ENABLE);
-                                switch(I2C_State)
+                                switch(I2C1_State)
+                                {
                                         case I2C_STATE_TX_PROGRESS:
                                         // send 1st data byte
                                         Tx_Idx = 0;
-                                        I2C_SendData(I2C1, I2C_Buffer[Tx_Idx]);
+                                        I2C_SendData(I2C1, I2C1_Buffer[Tx_Idx]);
                                         Tx_Idx++;
                                         // reset timeout
                                         I2C1_Timeout = SetDelay(I2C1_TIMEOUT); // after inactivity the I2C1 bus will be reset
                                         break;
                                         case I2C_STATE_RX_PROGRESS:
                                         Rx_Idx = 0;
                                         // disable acknoledge if only one byte has to be read
-                                        if(I2C_RxBufferSize == 1) I2C_AcknowledgeConfig (I2C1, DISABLE);
+                                        if(I2C1_RxBufferSize == 1) I2C_AcknowledgeConfig (I2C1, DISABLE);
                                         break;
                                         default: // unknown I2C state
                                         // should never happen
                                         I2C_GenerateSTOP (I2C1, ENABLE);
                                         VIC_ITCmd(I2C1_ITLine, DISABLE);
-                                        I2C_State = I2C_STATE_IDLE;
+                                        I2C1_State = I2C_STATE_IDLE;
-                                        I2C_Error = I2C_ERROR_UNKNOWN;
+                                        I2C1_Error = I2C_ERROR_UNKNOWN;
                                         return;
                                         break;
                                 }
                                 break;
                         // the master has transmitted a byte and slave has been acknowledged
                         case I2C_EVENT_MASTER_BYTE_TRANSMITTED:
                                 // some bytes have to be transmitted
-                                if(Tx_Idx < I2C_TxBufferSize)
+                                if(Tx_Idx < I2C1_TxBufferSize)
                                 {
-                                        I2C_SendData(I2C1, I2C_Buffer[Tx_Idx]);
+                                        I2C_SendData(I2C1, I2C1_Buffer[Tx_Idx]);
                                         Tx_Idx++;
+                                }
                                 else // last byte was send
+                                {
                                         // generate stop or repeated start condition
-                                        if (I2C_RxBufferSize > 0) // is any answer byte expected?
+                                        if (I2C1_RxBufferSize > 0) // is any answer byte expected?
+                                        {
-                                                I2C_Direction = I2C_MODE_RECEIVER; // switch to master receiver after repeated start condition
+                                                I2C1_Direction = I2C_MODE_RECEIVER; // switch to master receiver after repeated start condition
                                                 I2C_GenerateStart(I2C1, ENABLE);   // initiate repeated start condition on the bus
+                                        }
                                         else
                                         {   // stop communication
                                                 I2C_GenerateSTOP(I2C1, ENABLE); // generate stop condition to free the bus
                                                 VIC_ITCmd(I2C1_ITLine, DISABLE);
-                                                I2C_State = I2C_STATE_IDLE;                     // ready for new actions
+                                                I2C1_State = I2C_STATE_IDLE;                    // ready for new actions
-                                                I2C_Error = I2C_ERROR_NONE;
+                                                I2C1_Error = I2C_ERROR_NONE;
+                                        }
                                 }
                                 break;
                         // the master has received a byte from the slave
                         case I2C_EVENT_MASTER_BYTE_RECEIVED:
                                 // some bytes have to be received
-                                if ( Rx_Idx+1 < I2C_RxBufferSize)
+                                if ( Rx_Idx+1 < I2C1_RxBufferSize)
                                 {       // copy received byte  from the data register to the rx-buffer
-                                        I2C_Buffer[Rx_Idx] = I2C_ReceiveData(I2C1);
+                                        I2C1_Buffer[Rx_Idx] = I2C_ReceiveData(I2C1);
+                                }
                                 else // if the last byte was received
+                                {
                                         // generate a STOP condition on the bus before reading data register
                                         I2C_GenerateSTOP(I2C1, ENABLE);
-                                        I2C_Buffer[Rx_Idx] = I2C_ReceiveData(I2C1);
+                                        I2C1_Buffer[Rx_Idx] = I2C_ReceiveData(I2C1);
                                         // call the rx handler function to process recieved data
-                                        if(I2C_pRxHandler != NULL) (*I2C_pRxHandler)((u8*)I2C_Buffer, I2C_RxBufferSize);
+                                        if(I2C1_pRxHandler != NULL) (*I2C1_pRxHandler)((u8*)I2C1_Buffer, I2C1_RxBufferSize);
                                         I2C1_Timeout = SetDelay(I2C1_TIMEOUT);
                                         DebugOut.Analog[15]++;
                                         VIC_ITCmd(I2C1_ITLine, DISABLE);
-                                        I2C_State = I2C_STATE_IDLE;
+                                        I2C1_State = I2C_STATE_IDLE;
-                                        I2C_Error = I2C_ERROR_NONE;
+                                        I2C1_Error = I2C_ERROR_NONE;
                                         return;
+                                }
                                 Rx_Idx++;
                                 // if the 2nd last byte was received disable acknowledge for the last one
-                                if ( (Rx_Idx + 1) == I2C_RxBufferSize )
+                                if ( (Rx_Idx + 1) == I2C1_RxBufferSize )
                                 {
                                         I2C_AcknowledgeConfig(I2C1, DISABLE);
+                                }
                                 break;
                         default:// unknown event
                                 // should never happen
                                 I2C_GenerateSTOP (I2C1, ENABLE);
                                 VIC_ITCmd(I2C1_ITLine, DISABLE);
-                                I2C_State = I2C_STATE_IDLE;
+                                I2C1_State = I2C_STATE_IDLE;
-                                I2C_Error = I2C_ERROR_UNKNOWN;
+                                I2C1_Error = I2C_ERROR_UNKNOWN;
                                 break;
+                }
         }
         //IDISABLE;      // do not enable IRQ nesting for I2C!!!!
         VIC1->VAR = 0xFF; // write any value to VIC1 Vector address register
+}
 // ----------------------------------------------------------------------------------------
 // wait for end of transmission
-u8 I2C_WaitForEndOfTransmission(u32 timeout)
+u8 I2C1_WaitForEndOfTransmission(u32 timeout)
+{
         u32 time = SetDelay(timeout);
-        while(I2C_State != I2C_STATE_IDLE)
+        while(I2C1_State != I2C_STATE_IDLE)
         {
                 if(CheckDelay(time)) return(0);
         }
         return(1);
+}
 // ----------------------------------------------------------------------------------------
 // try to get access to the transfer buffer      within a timeout limit
 // returs 1 on success and 0 on error/timeout
-u8 I2C_LockBuffer(u32 timeout)
+u8 I2C1_LockBuffer(u32 timeout)
 {
-        if(I2C_WaitForEndOfTransmission(timeout))
+        if(I2C1_WaitForEndOfTransmission(timeout))
+        {
-                I2C_State = I2C_STATE_BUFFBUSY;
+                I2C1_State = I2C_STATE_BUFFBUSY;
-                I2C_Error = I2C_ERROR_UNKNOWN;
+                I2C1_Error = I2C_ERROR_UNKNOWN;
                 return(1);
+        }
         else return(0);
+}
 // ----------------------------------------------------------------------------------------
 // initate an i2c transmission
-u8 I2C_Transmission(u8 SlaveAddr, u8 TxBytes, I2C_pRxHandler_t pRxHandler, u8 RxBytes)
+u8 I2C1_Transmission(u8 SlaveAddr, u8 TxBytes, I2C_pRxHandler_t pRxHandler, u8 RxBytes)
+{
         u8 retval = 0;
-        if(I2C_State == I2C_STATE_BUFFBUSY)
+        if(I2C1_State == I2C_STATE_BUFFBUSY)
+        {
-                if((RxBytes > I2C_BUFFER_LEN) || (TxBytes > I2C_BUFFER_LEN))
+                if((RxBytes > I2C1_BUFFER_LEN) || (TxBytes > I2C1_BUFFER_LEN))
                 {
-                        I2C_State = I2C_STATE_IDLE;
+                        I2C1_State = I2C_STATE_IDLE;
                         return(retval);
                 }
-                I2C_RxBufferSize = RxBytes;
+                I2C1_RxBufferSize = RxBytes;
-                I2C_TxBufferSize = TxBytes;
+                I2C1_TxBufferSize = TxBytes;
                 // set direction to master transmitter
-                if( (I2C_TxBufferSize > 0) && (I2C_TxBufferSize < I2C_BUFFER_LEN) ) I2C_Direction = I2C_MODE_TRANSMITTER;
+                if( (I2C1_TxBufferSize > 0) && (I2C1_TxBufferSize < I2C1_BUFFER_LEN) ) I2C1_Direction = I2C_MODE_TRANSMITTER;
-                else if (( I2C_RxBufferSize > 0 ) && (I2C_RxBufferSize < I2C_BUFFER_LEN) ) I2C_Direction = I2C_MODE_RECEIVER;
+                else if (( I2C1_RxBufferSize > 0 ) && (I2C1_RxBufferSize < I2C1_BUFFER_LEN) ) I2C1_Direction = I2C_MODE_RECEIVER;
                 else // nothing to send or receive
+                {
-                        I2C_State = I2C_STATE_IDLE;
+                        I2C1_State = I2C_STATE_IDLE;
-                        I2C_Error = I2C_ERROR_NONE;
+                        I2C1_Error = I2C_ERROR_NONE;
-                        I2C_TxBufferSize = 0;
+                        I2C1_TxBufferSize = 0;

Subversion Repositories NaviCtrl

(root)/tags/V2.02a/i2c1.c @ 745 - Rev 469 → 470