i2c.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef  __I2C_H
#define  __I2C_H
 
#include <predef.h>
#include <ctype.h>
#include <sim.h>
#include <nbrtos.h>
 
 
#define TWIHS_SR_IOS (TWIHS_SR_SCL | TWIHS_SR_SDA)
 
struct I2CTxn_t {
    uint8_t *buf;
    uint32_t blen;
    uint8_t  regAddr[3];
    uint8_t  devAddr : 7;
    bool     RnW : 1;
    uint8_t  regAddrLen : 3;
    bool     bIssueStop : 1;
 
    void dump(uint32_t line);
};
 
class I2C;
 
class TwoWire;
 
/*-------------------------------------------------------------------------------------------------
 * Wire Interface Class
 *------------------------------------------------------------------------------------------------*/
 
class WireIntf {
    I2C     &i2c;           // I2C instance of this wire interface
    uint8_t txnBuf[128];    // Transaction buffer. Build up transaction before being flushed to the I2C bus
    uint8_t txnLen;         // Current transaction length
    uint8_t devAddr;        // I2C slave device adddress to be accessed
    uint8_t bytesRead;      // Number of bytes read, returned by requestFrom(). Provides number of bytes available to read()
    uint8_t readIdx;        // Read index. Location in the transaction buffer of next byte to be read
    bool    bTxnStarted;    // Whether or not the wire interface is in an active transaction
    bool    bBusStarted;    // Whether or not the bus is active (h/w signal state)
 
public:
    WireIntf(I2C &module);
 
    void begin();
 
    uint32_t requestFrom(uint8_t addr, uint32_t len, bool stop = true);
 
    void beginTransmission(uint8_t addr);
 
    void endTransmission(bool stop = true);
 
    uint32_t write(uint8_t dat);
 
    uint32_t write(char * str);
 
    uint32_t write(uint8_t * buf, uint32_t len);
 
    uint32_t available();
 
    uint8_t read();
 
    void flush(bool bIssueStop = false);
};
 
 
/*
 * I2C WireIntf objects instantiated by the system.
 *
 * Provides access to the all the I2C peripherals on the processor. The I2C peripherals available will vary by platform.
 * For example, Wire.read(); will execute a read operation on I2C module 0.
 */
 
 
/*-------------------------------------------------------------------------------------------------
 * I2C Class
 *------------------------------------------------------------------------------------------------*/
 
class I2C {
public:
    enum Result_t {
        I2C_RES_ACK,        
        I2C_RES_NACK,       
        I2C_RES_ARB_LST,    
        I2C_RES_BUSY,       
        I2C_RES_ARG         
    };
private:
    enum TxnStat {
        TXN_RDY,
        TXN_IN_PROGRESS,
        TXN_WAITING
    };
 
    Twihs &twi;
    int modNum;
    TxnStat txnStatus;
    Result_t txnResult;
    uint32_t sticky_sr;
    uint8_t  iadrAddressSize;   // Number of address register bytes, 0 - 3
 
    volatile I2CTxn_t *pTxn;
    OS_SEM txnSem;
 
    void isr();
    void isr_rx(uint32_t sr);
    void isr_tx(uint32_t sr);
 
    inline uint32_t getStatus()
        { uint32_t sr = twi.TWIHS_SR; sticky_sr |= sr; return sr; }
    inline uint32_t getStickyStatus()
        { uint32_t sr = twi.TWIHS_SR; sticky_sr |= sr; return sticky_sr; }
    inline void clrStickyStatus() { sticky_sr = 0; }
 
    inline bool busBusy()
        { return ((getStatus() & TWIHS_SR_IOS) != TWIHS_SR_IOS); }
 
    void start(uint8_t deviceAddr, bool rnw, uint8_t regAddrlen = 0, bool bIssueStop = false);
    void restart(uint8_t deviceAddr, bool rnw, uint8_t regAddrlen = 0, bool bIssueStop = false);
    void stop();
 
    Result_t write8(uint8_t dat);
    Result_t read8(uint8_t &dat);
    Result_t read8Restart(uint8_t &dat, uint8_t addr, bool Rnw); 
 
public:
    I2C(int module);
 
    // Copy constructor
    I2C(const I2C & rhs)
        : twi(rhs.twi), modNum(rhs.modNum), txnStatus(rhs.txnStatus)
    {}
 
    void setup(uint32_t busSpeed);
 
    void resetBus();
 
    Result_t DoTransaction(I2CTxn_t *pTransaction, bool bRepeatedStart = false);
 
    inline void setNumAddressBytes(uint8_t numAddressBytes = 1) { iadrAddressSize = numAddressBytes; }
 
    Result_t writeReg8(uint8_t devAddr, uint32_t reg, uint8_t data);
 
    Result_t readReg8(uint8_t devAddr, uint32_t reg, uint8_t &data);
 
    Result_t writeRegN(uint8_t devAddr, uint32_t reg, const uint8_t *buf, uint32_t blen);
 
    Result_t readRegN(uint8_t devAddr, uint32_t reg, uint8_t *buf, uint32_t blen);
 
    // Static implementations of the C++ class that can be used if you prefer a C style interface
    static Result_t writeReg8(int module, uint8_t devAddr, uint32_t reg, uint8_t dat);
    static Result_t readReg8(int module, uint8_t devAddr, uint32_t reg, uint8_t &dat);
    static Result_t writeRegN(int module, uint8_t devAddr, uint32_t reg, const uint8_t *buf, uint32_t blen);
    static Result_t readRegN(int module, uint8_t devAddr, uint32_t reg, uint8_t *buf, uint32_t blen);
 
    void ShowStat(TxnStat s,const char * lab="");
 
    // These functions are for internal use only.
    void dump(uint32_t line);
    friend void TWIHS0_Handler();
    friend void TWIHS1_Handler();
    friend void TWIHS2_Handler();
 
    friend class WireIntf;
    friend class TwoWire;
 
};  // end class I2C
 
 
// I2C instantions exist for all I2C (TWIHS) peripherals. They are accessed as array: i2c[0], i2c[1], i2c[2]
extern I2C i2c[];
 
inline I2C::Result_t I2C::writeReg8(int module, uint8_t devAddr, uint32_t reg, uint8_t dat)
{
    if (module < 0) { return I2C_RES_NACK; }
    if (module > 2) { return I2C_RES_NACK; }
    return i2c[module].writeReg8(devAddr, reg, dat);
}
 
inline I2C::Result_t I2C::readReg8(int module, uint8_t devAddr, uint32_t reg, uint8_t &dat)
{
    if (module < 0) { return I2C_RES_NACK; }
    if (module > 2) { return I2C_RES_NACK; }
    return i2c[module].readReg8(devAddr, reg, dat);
}
 
inline I2C::Result_t I2C::writeRegN(int module, uint8_t devAddr, uint32_t reg, const uint8_t *buf, uint32_t blen)
{
    if (module < 0) { return I2C_RES_NACK; }
    if (module > 2) { return I2C_RES_NACK; }
    return i2c[module].writeRegN(devAddr, reg, buf, blen);
}
inline I2C::Result_t I2C::readRegN(int module, uint8_t devAddr, uint32_t reg, uint8_t *buf, uint32_t blen)
{
    if (module < 0) { return I2C_RES_NACK; }
    if (module > 2) { return I2C_RES_NACK; }
    return i2c[module].readRegN(devAddr, reg, buf, blen);
}
 
 
/*-------------------------------------------------------------------------------------------------
 * I2C Device Class
 *------------------------------------------------------------------------------------------------*/
class I2CDevice {
 
private:
    I2C     *pI2CInterface;     // Pointer to I2C class object for peripheral/interface
    uint8_t devAddress;         // I2C device address, 1 byte, 1 to 127
    uint8_t numRegAddrBytes;    // Number of register address bytes to send to device, 0 to 3
 
public:
 
    inline I2CDevice(I2C & pInterface, uint8_t deviceAddress, uint8_t numAddressBytes = 1)
    {
        pI2CInterface =     &pInterface;        // Pointer to the I2C peripheral module object
        devAddress =        deviceAddress;      // Device I2C address
        numRegAddrBytes =   numAddressBytes;    // Number of bytes to send for register address: 0 - 3
    }
 
    inline uint8_t getI2CAddress() { return devAddress; }
 
 
    inline void setup(uint32_t busSpeed);
 
    inline void resetBus();
 
 
    inline I2C::Result_t writeReg8(uint32_t reg, uint8_t data)
    {
        pI2CInterface->setNumAddressBytes(numRegAddrBytes);
        return pI2CInterface->writeReg8(devAddress, reg, data);
    }
 
    inline I2C::Result_t readReg8(uint32_t reg, uint8_t &data)
    {
        pI2CInterface->setNumAddressBytes(numRegAddrBytes);
        return pI2CInterface->readReg8(devAddress, reg, data);
    }
 
    inline I2C::Result_t writeRegN(uint32_t reg, const uint8_t *buf, uint32_t blen)
    {
        pI2CInterface->setNumAddressBytes(numRegAddrBytes);
        return pI2CInterface->writeRegN(devAddress, reg, buf, blen);
    }
 
    inline I2C::Result_t readRegN(uint32_t reg, uint8_t *buf, uint32_t blen)
    {
        pI2CInterface->setNumAddressBytes(numRegAddrBytes);
        return pI2CInterface->readRegN(devAddress, reg, buf, blen);
    }
};
 
 
 
#endif   /* ----- #ifndef __I2C_H  ----- */