Wire.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef _WIRE_H
#define _WIRE_H
#include <sim.h> /*on-chip register definitions*/
#include <nbrtos.h>
#include <string.h>
#include <pins.h>
 
 
//Callback definition for target device receiving data
typedef void(slave_rx_handler)(int num_rx);
//call back definition for target device called at start of transaction
typedef void(slave_rq_handler)();
 
const int wire_success         = 0;        
const int wire_data_too_big    = 1;
const int wire_NACK_on_address = 2;   
const int wire_NACK_on_data    = 3;      
const int wire_other_error     = 4;       
const int wire_timeout         = 5;           
 
class TwoWire
{
    #include <wire_guts.h>   // Processor specific code
 
    static const uint32_t I2C_RX_BUFFER_SIZE = 256;
    uint8_t InRxBuf[I2C_RX_BUFFER_SIZE];
    size_t m_rx_get_pos;
    size_t m_rx_put_pos;
 
    static const uint32_t I2C_TX_BUFFER_SIZE = 256;
    uint8_t OutTxBuf[I2C_TX_BUFFER_SIZE];
    size_t m_tx_get_pos;
    size_t m_tx_put_pos;
 
    uint32_t m_ClockBaud;
    uint32_t m_TimeOut_usec;
    uint32_t m_nBegins;
    uint8_t m_slave_addr;
    uint8_t m_target_addr;
    uint32_t m_flags;
    uint32_t m_NoHang_TimeOut;   // Ticks
 
    bool flagset(uint32_t f) { return ((m_flags & f) != 0); }
    void setflag(uint32_t f) { m_flags |= f; }
    void clrflag(uint32_t f) { m_flags &= (~f); }
 
   public:
    TwoWire(void);
 
    TwoWire(int mod);
 
    TwoWire(PinIO scl, PinIO sda);
    TwoWire(int sclpin_num, int sdapin_num);
 
    ~TwoWire();
 
    void setClock(uint32_t clockbaud) { m_ClockBaud = clockbaud; }
 
    void begin(uint8_t slave_addr = 0);
 
    void end();
 
    void beginTransmission(uint8_t address);
 
    int endTransmission(bool bStop = true);
 
    size_t write(const uint8_t *pdata, int len);
 
    size_t write(char v) { return write((uint8_t *)&v, 1); };
 
    size_t write(uint8_t v) { return write((uint8_t *)&v, 1); };
 
    size_t write(const char *pStr, int len = -1)
    {
        if (len == -1) len = strlen(pStr);
        return write((uint8_t *)pStr, len);
    }
 
    int requestFrom(uint8_t address, size_t quantity, bool stop = true);
 
    size_t available();
 
    size_t read(uint8_t *pbuf, size_t maxlen);
 
    uint8_t read()
    {
        uint8_t v = 0;
        read(&v, 1);
        return v;
    };
 
    void onReceive(slave_rx_handler *handler);
 
    void onRequest(slave_rq_handler *handler);
 
    void setWireTimeout(int timeout_usec = 0, bool reset_on_timeout = false);
 
    void clearTimeout();
 
    bool getWireTimeoutFlag();
 
    void reset();
 
    bool ping(uint8_t addr);
 
    int writeRegN(uint8_t dAddr, uint32_t reg, const uint8_t *buf, uint32_t blen);
 
    int readRegN(uint8_t dAddr, uint32_t reg, uint8_t *buf, uint32_t blen);
 
    inline int writeReg8(uint8_t dAddr, uint32_t reg, uint8_t data) { return writeRegN(dAddr, reg, &data, 1); }
 
    inline int readReg8(uint8_t dAddr, uint32_t reg, uint8_t &data) { return readRegN(dAddr, reg, &data, 1); }
 
};
 
extern class TwoWire Wire;
 
class TwoWireObject
{
    TwoWire &theWire;
    uint8_t the_addr;
 
    public:
    TwoWireObject(TwoWire &w, uint8_t addr) : theWire{w}, the_addr{addr} {};
    TwoWireObject(uint8_t addr) : theWire{Wire}, the_addr{addr} {};
 
    void reset() { theWire.reset(); }
 
    bool ping() { return theWire.ping(the_addr); }
 
    int writeRegN(uint32_t reg, const uint8_t *buf, uint32_t blen) { return theWire.writeRegN(the_addr, reg, buf, blen); }
 
    int readRegN(uint32_t reg, uint8_t *buf, uint32_t blen) { return theWire.readRegN(the_addr, reg, buf, blen); }
 
    inline int writeReg8(uint32_t reg, uint8_t data) { return writeRegN(reg, &data, 1); }
 
    inline int readReg8(uint32_t reg, uint8_t &data) { return readRegN(reg, &data, 1); }
};
 
#endif