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>
 

typedef void(slave_rx_handler)(int num_rx);

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;
 
    // These carry in-class initialisers so that an object whose constructor
    // could not bind a hardware module still has defined state. 
    uint32_t m_ClockBaud = 100000;
    uint32_t m_TimeOut_usec = 1000;
    uint32_t m_nBegins = 0;
    uint8_t m_slave_addr = 0;
    uint8_t m_target_addr = 0;
    uint32_t m_flags = 0;
    uint32_t m_NoHang_TimeOut = 2;   // Ticks
    uint8_t m_numAddressBytes = 1;   // Register address width, 0 - 3, default 1
 
    // False until a constructor successfully binds this object to a hardware
    // I2C module. CoreConstructor() is the only thing that sets it true, so it
    // is the single test for "is this object usable" on every platform.
    bool m_bound = false;
 
    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); }
 
    // Queue the register address, most significant byte first, using the width
    // set by setNumAddressBytes(). A width of 0 queues nothing.
    void sendRegAddress(uint32_t reg)
    {
        for (int i = (int)m_numAddressBytes - 1; i >= 0; i--)
        {
            write((uint8_t)(reg >> (8 * i)));
        }
    }
 
   public:
    TwoWire(void);

    TwoWire(int mod);

    TwoWire(PinIO scl, PinIO sda);

    TwoWire(int sclpin_num, int sdapin_num);

    ~TwoWire();

    bool isValid() const { return m_bound; }

    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(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);

    inline void setNumAddressBytes(uint8_t numAddressBytes = 1) { m_numAddressBytes = numAddressBytes; }

    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