multichanneli2c.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
/*-----------------------------------------------------------------------------
   NetBurner I2C Multi-Master I2C Driver.
   Multi-Master I2C will enable operation as a master device on the I2C bus when
   activly seeking to communicate.  When idle,  the NetBurner will act as a slave
   device so other I2C masters can use the bus.
 
   Note: If your NetBurner device is the only master on the I2C bus, you may
   choose to use the Master-Only I2C driver to conserve system resources
-------------------------------------------------------------------------------*/
 
#ifndef _MULTICHANNELI2C_H
#define _MULTICHANNELI2C_H
#include <basictypes.h>
#include <nbrtos.h>
#include <i2c_class.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#define I2C_MAX_BUF_SIZE (64)   // Size allocated to input and output buffers in slave mode I2C
 
#define DEFAULT_I2C_MODULE (0)
 
/* defined I2C Timeout values will be used if user does not include the 'ticks_to_wait'
   parameter when calling I2C functions                                                  */
#define I2C_RX_TX_TIMEOUT (5)    // Ticks allowed before timeout of a single byte transmission
#define I2C_START_TIMEOUT (20)   // Ticks allowed before timeout when attempting start on I2C bus
 
#define I2C_SLAVE_TX_TERM_CHAR (0)   // Terminating char to be sent when Slave TX buffer is empty
 
#define I2C_OK (0)               
#define I2C_NEXT_WRITE_OK (1)    
#define I2C_NEXT_READ_OK (2)     
#define I2C_MASTER_OK (3)        
#define I2C_TIMEOUT (4)          
#define I2C_BUS_NOT_AVAIL (5)    
#define I2C_NOT_READY (6)        
#define I2C_LOST_ARB (7)         
#define I2C_LOST_ARB_ADD (8)     
#define I2C_NO_LINK_RX_ACK (9)   
// The following defines were created to allow the multi and master-only drivers to
// have the same function calls.  i.e. Multi_I2CInit(); is the same as calling I2CInit();
//#define I2CInit      MultiChannel_I2CInit
//#define I2CSendBuf   MultiChannel_I2CSendBuf
//#define I2CReadBuf   MultiChannel_I2CReadBuf
//#define I2CRestart   MultiChannel_I2CRestart
//#define I2CStart     MultiChannel_I2CStart
//#define I2CStop      MultiChannel_I2CStop
//#define I2CSend      MultiChannel_I2CSend
//#define I2CRead      MultiChannel_I2CRead
 
// Setup sim references to i2c struct
#define I2C_SR i2cModule->i2sr
#define I2C_CR i2cModule->i2cr
#define I2C_DR i2cModule->i2dr
#define I2C_FDR i2cModule->i2fdr
#define I2C_ADR i2cModule->i2adr
 
    void MultiChannel_I2CInit(int moduleNum = DEFAULT_I2C_MODULE, uint8_t slave_Addr = 0x08, uint8_t freqdiv = 0x3C);
 
    uint8_t MultiChannel_I2CSendBuf(int moduleNum, uint8_t addr, puint8_t buf, int num, bool stop = true);
 
    uint8_t MultiChannel_I2CReadBuf(int moduleNum, uint8_t addr, puint8_t buf, int num, bool stop = true);
 
    void I2CMultiChannelResetPeripheral(int moduleNum);
 
    /*----------------------------------------------------------------------------
    bool I2CRXAvail();
 
    returns true if data is available in the Slave RX buffer
    */
    bool I2CRXAvail();
 
    /*----------------------------------------------------------------------------
    uint32_t I2CTXAvail();
 
    returns amount of free space available in Slave TX buffer
    */
    uint32_t I2CTXAvail();
 
    /*----------------------------------------------------------------------------
    uint8_t I2CGetByte();
 
    This function will pend on a slave recieve I2C semaphore
 
    returns last unread uint8_t received as a I2C Slave
    */
    uint8_t I2CGetByte();
 
    /*----------------------------------------------------------------------------
    bool I2CFillSlaveTXBuf(puint8_t buf, uint32_t num, bool restart = true);
 
    This will put the first 'num' BYTES from the buffer 'buf' into the
    I2C Slave TX buffer and clear the previously-read contents of the buffer.
    The 'restart' parameter tells the slave transmitter how to terminate
    if 'restart' = true then restart next tx from begining TX buffer (A new slave fill replaces buffer);
    if 'false' continue next tx from last slave tx,(A new slave fill adds to buffer at last read byte);
    In I2C multi.h there is a I2C_SLAVE_TX_TERM_CHAR defined that will decide the terminating char (if any) to send
    when the slave tx buffer is empty
 
    returns false if failed to copy data
    */
    uint8_t I2CFillSlaveTXBuf(puint8_t buf, uint32_t num, bool restart = true);
 
    /*----------------------------------------------------------------------------
    uint8_t ( *I2C_SlaveTX_Callback )( );
 
    If this callback is pointed to a function then it will be called when
    retreiving the data to be sent to the master.  This will bypass the circular
    buffer functions "I2CTXAvail" and "I2CFillSlaveTXBuf" used when transmitting
    data as a slave.
 
    returns the data to be sent to the master
    */
    extern uint8_t (*I2C_SlaveTX_Callback)();
 
    /*----------------------------------------------------------------------------
    void ( *I2C_SlaveTX_NAK_Callback )( );
 
    If this callback is pointed to a function then it will be called when
    the recieving master device sends a NAK.  This indicates that the master
    device will not be reading any more data from the slave transmitter.
 
    */
    extern void (*I2C_SlaveTX_NAK_Callback)();
 
    /*----------------------------------------------------------------------------
    void ( *I2C_SlaveRX_Callback )( uint8_t RX_Data);
 
    If this callback is pointed to a function then it will be called when
    storing the data received from the master.  This will bypass the circular
    buffer functions "I2CRXAvail" and "I2CGetByte" used when receiving
    data as a slave.
 
    uint8_t RX_Data - Passes the received data to the callback function
 
    returns nothing
    */
    extern void (*I2C_SlaveRX_Callback)(uint8_t RX_Data);
 
#define I2C_START_READ (1)   // defines to be used for bRead_Not_Write
#define I2C_START_WRITE (0)
    uint8_t MultiChannel_I2CRestart(int moduleNum, uint8_t addr, bool Read_Not_Write, uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT);
 
    /*------------------------------------------------------------------------------------------
          Advanced NetBurner I2C Functions
 
    The following functions are used for advanced communications on using the I2C bus.  These
    functions are useful if user wishes to talk to a device that does not follow the Phillips
    I2C standard.  One example is an eeprom that first must be addressed and then read from
    with no restart in between.
    Data must be sent or received a byte at a time.  Also user must check function returns
    to verify the status of the bus before performing the next option.
    -------------------------------------------------------------------------------------------
    ===========================================================================================*/
 
    uint8_t MultiChannel_I2CStart(int moduleNum, uint8_t addr, bool Read_Not_Write, uint32_t ticks_to_wait = I2C_START_TIMEOUT);
 
    uint8_t MultiChannel_I2CStop(int moduleNum = DEFAULT_I2C_MODULE, uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT);
 
    uint8_t MultiChannel_I2CSend(int moduleNum, uint8_t val, uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT);
 
    uint8_t MultiChannel_I2CRead(int moduleNum, puint8_t val, uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT);
 
    // Struct that contains I2C Slave I/O Buffers
    struct I2C_Slave_Record
    {
        OS_SEM I2C_Slave_RX_Semaphore;   // semaphore used to determine when a slave RX interrupt occurs
 
        volatile uint8_t *pI2CRxbuf;
        volatile uint8_t *pI2CTxbuf;
 
        volatile uint32_t I2Crx_put;
        volatile uint32_t I2Crx_get;
 
        volatile uint32_t I2Ctx_put;
        volatile uint32_t I2Ctx_get;
    };
 
/*---------------------------------------------------------------------------
         Useful I2C macros
----------------------------------------------------------------------------*/
#define I2C_SR_BUSY (((0x20 & I2C_SR) == 0x20))             
#define I2C_CR_SLAVE (((0x20 & I2C_CR) == 0x00))            
#define I2C_SR_ARB_LOST (((0x10 & I2C_SR) == 0x10))         
#define I2C_SR_ADRES_AS_SLAVE (((0x40 & I2C_SR) == 0x40))   
#define I2C_SR_SLAVE_TX (((0x04 & I2C_SR) == 0x04))         
 
#define I2C_CR_TX (((0x10 & I2C_CR) == 0x10))       
#define I2C_SR_RX_ACK (((0x01 & I2C_SR) == 0x00))   
#define I2C_CR_RX_ACK (((0x08 & I2C_CR) == 0x00))   
 
#define I2C_SET_NO_ACK ((I2C_CR |= 0x08))         
#define I2C_SET_ACK ((I2C_CR &= 0xF7))            
#define I2C_SET_TX ((I2C_CR |= 0x10))             
#define I2C_SET_RX ((I2C_CR &= 0xEF))             
#define I2C_SET_REPEAT_START ((I2C_CR |= 0x04))   
#define I2C_CLR_ARB_LOST ((I2C_SR &= 0xEF))       
    //----------------------------------------------------------------------------
 
    inline void I2CInit(uint8_t slave_Addr = 0x08, uint8_t freqdiv = 0x3C)
    {
        MultiChannel_I2CInit(DEFAULT_I2C_MODULE, slave_Addr, freqdiv);
    }
 
    inline void Mulit_I2CInit(uint8_t slave_Addr = 0x08, uint8_t freqdiv = 0x3C)
    {
        MultiChannel_I2CInit(DEFAULT_I2C_MODULE, slave_Addr, freqdiv);
    }
 
    inline uint8_t I2CSendBuf(uint8_t addr, puint8_t buf, int num, bool stop = true)
    {
        return MultiChannel_I2CSendBuf(DEFAULT_I2C_MODULE, addr, buf, num, stop);
    }
 
    inline uint8_t Multi_I2CSendBuf(uint8_t addr, puint8_t buf, int num, bool stop = true)
    {
        return MultiChannel_I2CSendBuf(DEFAULT_I2C_MODULE, addr, buf, num, stop);
    }
 
    inline uint8_t I2CReadBuf(uint8_t addr, puint8_t buf, int num, bool stop = true)
    {
        return MultiChannel_I2CReadBuf(DEFAULT_I2C_MODULE, addr, buf, num, stop);
    }
 
    inline uint8_t Multi_I2CReadBuf(uint8_t addr, puint8_t buf, int num, bool stop = true)
    {
        return MultiChannel_I2CReadBuf(DEFAULT_I2C_MODULE, addr, buf, num, stop);
    }
 
    inline uint8_t I2CRestart(uint8_t addr, bool Read_Not_Write, uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT)
    {
        return MultiChannel_I2CRestart(DEFAULT_I2C_MODULE, addr, Read_Not_Write, ticks_to_wait);
    }
 
    inline uint8_t Multi_I2CRestart(uint8_t addr, bool Read_Not_Write, uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT)
    {
        return MultiChannel_I2CRestart(DEFAULT_I2C_MODULE, addr, Read_Not_Write, ticks_to_wait);
    }
 
    inline uint8_t I2CStart(uint8_t addr, bool Read_Not_Write, uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT)
    {
        return MultiChannel_I2CStart(DEFAULT_I2C_MODULE, addr, Read_Not_Write, ticks_to_wait);
    }
 
    inline uint8_t Multi_I2CStart(uint8_t addr, bool Read_Not_Write, uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT)
    {
        return MultiChannel_I2CStart(DEFAULT_I2C_MODULE, addr, Read_Not_Write, ticks_to_wait);
    }
 
    inline uint8_t I2CStop(uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT) { return MultiChannel_I2CStop(DEFAULT_I2C_MODULE, ticks_to_wait); }
 
    inline uint8_t Multi_I2CStop(uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT)
    {
        return MultiChannel_I2CStop(DEFAULT_I2C_MODULE, ticks_to_wait);
    }
 
    inline uint8_t I2CSend(uint8_t val, uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT)
    {
        return MultiChannel_I2CSend(DEFAULT_I2C_MODULE, val, ticks_to_wait);
    }
 
    inline uint8_t Multi_I2CSend(uint8_t val, uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT)
    {
        return MultiChannel_I2CSend(DEFAULT_I2C_MODULE, val, ticks_to_wait);
    }
 
    inline uint8_t I2CRead(puint8_t val, uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT)
    {
        return MultiChannel_I2CRead(DEFAULT_I2C_MODULE, val, ticks_to_wait);
    }
 
    inline uint8_t Multi_I2CRead(puint8_t val, uint32_t ticks_to_wait = I2C_RX_TX_TIMEOUT)
    {
        return MultiChannel_I2CRead(DEFAULT_I2C_MODULE, val, ticks_to_wait);
    }
 
#ifdef __cplusplus
}
#endif
 
#endif