ngcbI2C.hpp

Go to the documentation of this file.

#ifndef ngcbI2C_H
#define ngcbI2C_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#include <stdio.h>
#include <stdlib.h>

#define ngcbI2C_TX_SIZE7(n)  ((((n + 1) * 8) + 2) * 3)

#define ngcbI2C_TX_SIZE10(n) ((((n + 2) * 8) + 2) * 3)
 
/*
 * Error codes
 */

#define ngcbI2C_ERR_CLK   0x0000000A  

#define ngcbI2C_ERR_ACK   0x0000000B   

class ngcbI2C {
public:
  ngcbI2C() {Init_(0, 1, 0);}

  explicit ngcbI2C(int cnt) {Init_(0, 1, cnt);}

  ngcbI2C(int scl, int sda) {Init_(scl, sda, 0);}

  ngcbI2C(int scl, int sda, int cnt) {Init_(scl, sda, cnt);}

  ngcbI2C(int scl, int sda, int sclIn, int sdaIn, int ackIn, int cnt) {
    Init_(scl, sda, cnt);
    sclIn_ = sclIn;
    sdaIn_ = sdaIn;
    ackIn_ = ackIn;
  }

  virtual ~ngcbI2C() {}
  
  char *ErrMsg() {return (erms_);}

  void AckOn() {ignoreAck_ = 0;}

  void AckOff() {ignoreAck_ = 1;}

  void SCL_IN(int bit) {sclIn_ = bit;}

  void SDA_IN(int bit) {sdaIn_ = bit; ackIn_ = sdaIn_;}

  void ACK_IN(int bit) {ackIn_ = bit;}

  void SDA_DIR_SWITCH(int bit) {sdaDirSwitch_ = bit;}

  void SCL_DIR_SWITCH(int bit) {sclDirSwitch_ = bit;}

  void ClkStretching(int rx, int tx) {
    /*
     * Clock-stretching capability on RX-operations
     */
    if (rx < 0) rxStretching_ = 0;
    else rxStretching_ = rx;
 
    /*
     * Clock-stretching capability on TX-operations
     */
    if (tx < 0) txStretching_ = 0;
    else txStretching_ = tx;
  }

  void ClkStretchCnt(int cnt) {
    if (cnt < 0) clkStretchCnt_ = 0;
    else clkStretchCnt_ = cnt;
  }

  int ClkStretchCnt() {return (clkStretchCnt_);}

  int Write(int addr, const char *byte, int n) {
    int byteBuf[8 * 3];
    int *b;
    int i = 0;
    int res;
 
    erms_[0] = '\0';
 
    /* 
     * Start
     */
    res = Start_();
    if (res != 0)
      {
      return (res);
      }
    
    b = byteBuf;
 
    /*
     * 7-Bit address
     */
    for (i=6;i>=0;i--)
      {
      *b++ = ((addr >> i) & 0x1) << sda_;
      *b++ = (((addr >> i) & 0x1) << sda_) | (1 << scl_);
      *b++ = ((addr >> i) & 0x1) << sda_;
      }
    
    /*
     * R/W bit (0 for write-operation)
     */
    *b++ = 0x0;
    *b++ = 1 << scl_;
    *b++ = 0x0; 
    
    /*
     * Send the address byte
     */
    res = SendByte_(byteBuf);
    if (res != 0)
      {
      return (res);
      }
 
    /*
     * Now send the n data bytes
     */
    for (i=0;i<n;i++)
      {
      int j;
 
      b = byteBuf;
      for (j=7;j>=0;j--)
    {
    *b++ = ((byte[i] >> j) & 0x1) << sda_;
    *b++ = (((byte[i] >> j) & 0x1) << sda_) | (1 << scl_);
    *b++ = ((byte[i] >> j) & 0x1) << sda_;
    }
      
      res = SendByte_(byteBuf);
      if (res != 0)
    {
    return (res);
    }
      }
 
    /* 
     * Stop
     */
    res = Stop_();
    if (res != 0)
      {
      return (res);
      }
 
    return (0);
  }
      
  int Write10(int addr, const char *byte, int n) {
    int byteBuf[8 * 3];
    int *b;
    int i = 0;
    int res;
    int a0 = addr & 0xff;
    int a1 = 0xf0 | ((addr >> 7) & 0x6);
 
    erms_[0] = '\0';
 
    /* 
     * Start
     */
    res = Start_();
    if (res != 0)
      {
      return (res);
      }
 
    /*
     * 10-Bit marker + 2 MSB bits of address + R/W
     */
    b = byteBuf;
    for (i=7;i>=0;i--)
      {
      *b++ = ((a1 >> i) & 0x1) << sda_;
      *b++ = (((a1 >> i) & 0x1) << sda_) | (1 << scl_);
      *b++ = ((a1 >> i) & 0x1) << sda_;
      }
    res = SendByte_(byteBuf);
    if (res != 0)
      {
      return (res);
      }
    
    /*
     * 8 LSB bits of address
     */
    b = byteBuf;
    for (i=7;i>=0;i--)
      {
      *b++ = ((a0 >> i) & 0x1) << sda_;
      *b++ = (((a0 >> i) & 0x1) << sda_) | (1 << scl_);
      *b++ = ((a0 >> i) & 0x1) << sda_;
      }
    res = SendByte_(byteBuf);
    if (res != 0)
      {
      return (res);
      }
    
    /*
     * Now send the n bytes
     */
    for (i=0;i<n;i++)
      {
      int j;
 
      b = byteBuf;
      for (j=7;j>=0;j--)
    {
    *b++ = ((byte[i] >> j) & 0x1) << sda_;
    *b++ = (((byte[i] >> j) & 0x1) << sda_) | (1 << scl_);
    *b++ = ((byte[i] >> j) & 0x1) << sda_;
    }
      
      res = SendByte_(byteBuf);
      if (res != 0)
    {
    return (res);
    }
      }
 
    /* 
     * Stop
     */
    res = Stop_();
    if (res != 0)
      {
      return (res);
      }
 
    return (0);
  }

  int Read(int addr, char *byte, int n) {
    int byteBuf[8 * 3];
    int *b;
    int i = 0;
    int res;
 
    erms_[0] = '\0';
 
    /* 
     * Start
     */
    res = Start_();
    if (res != 0)
      {
      return (res);
      }
    
    b = byteBuf;
 
    /*
     * 7-Bit address
     */
    for (i=6;i>=0;i--)
      {
      *b++ = ((addr >> i) & 0x1) << sda_;
      *b++ = (((addr >> i) & 0x1) << sda_) | (1 << scl_);
      *b++ = ((addr >> i) & 0x1) << sda_;
      }
    
    /*
     * R/W bit (1 for read-operation)
     */
    *b++ = (0x1 << sda_) | (0x0 << scl_);
    *b++ = (0x1 << sda_) | (0x1 << scl_);
    *b++ = (0x1 << sda_) | (0x0 << scl_);
    
    /*
     * Send the address byte
     */
    res = SendByte_(byteBuf);
    if (res != 0)
      {
      return (res);
      }
 
    /*
     * Now read the n bytes
     */
    for (i=0;i<n;i++)
      {
      res = RecvByte_(&byte[i], (i == (n-1)));
      if (res != 0)
    {
    return (res);
    }
      }
 
    /* 
     * Stop
     */
    res = Stop_();
    if (res != 0)
      {
      return (res);
      }
 
    return (0);
  }

  int Read10(int addr, char *byte, int n) {
    int byteBuf[8 * 3];
    int *b;
    int i = 0;
    int res;
    int a0 = addr & 0xff;
    int a1 = 0xf1 | ((addr >> 7) & 0x6);
 
    erms_[0] = '\0';
 
    /* 
     * Start
     */
    res = Start_();
    if (res != 0)
      {
      return (res);
      }
 
    /*
     * 10-Bit marker + 2 MSB bits of address + R/W
     */
    b = byteBuf;
    for (i=7;i>=0;i--)
      {
      *b++ = ((a1 >> i) & 0x1) << sda_;
      *b++ = (((a1 >> i) & 0x1) << sda_) | (1 << scl_);
      *b++ = ((a1 >> i) & 0x1) << sda_;
      }
    res = SendByte_(byteBuf);
    if (res != 0)
      {
      return (res);
      }
    
    /*
     * 8 LSB bits of address
     */
    b = byteBuf;
    for (i=7;i>=0;i--)
      {
      *b++ = ((a0 >> i) & 0x1) << sda_;
      *b++ = (((a0 >> i) & 0x1) << sda_) | (1 << scl_);
      *b++ = ((a0 >> i) & 0x1) << sda_;
      }
    res = SendByte_(byteBuf);
    if (res != 0)
      {
      return (res);
      }
    
    /*
     * Now read the n bytes
     */
    for (i=0;i<n;i++)
      {
      res = RecvByte_(&byte[i]);
      if (res != 0)
    {
    return (res);
    }
      }
 
    /* 
     * Stop
     */
    res = Stop_();
    if (res != 0)
      {
      return (res);
      }
 
    return (0);
  }

  int LastState() {
    int s = lastState_ & (1 << sda_) & (1 << scl_);
    return (s);
  }
 
protected:
  virtual int OutCB(int d, int *resultCode, char *erms) {
    char s[33];
    *resultCode = 0;
    erms[0] = '\0';
    Int2Bin_(s, d);
    fprintf(stdout, "<%s>\n", s);
    return (0);
  }

  virtual int InCB(int *d, int *resultCode, char *erms) {
    *resultCode = 0;
    erms[0] = '\0';
    *d = 0;
    return (0);
  }
    
private: 
  char erms_[256];

  int scl_;         

  int sda_; 

  int sclIn_; 

  int sdaIn_; 

  int ackIn_;  

  int sdaDirSwitch_;  

  int sclDirSwitch_;  

  int lastClkState_;  

  int clkStretchCnt_; 

  int ignoreAck_;   

  int txStretching_;  

  int rxStretching_; 

  int lastState_;     

  void Init_(int scl, int sda, int cnt) {
    scl_ = scl;
    sda_ = sda;
    clkStretchCnt_ = cnt;
 
    sclIn_ = scl_;      // same as SCL output
    sdaIn_ = sda_;      // same as SDA output
    ackIn_ = sdaIn_;    // same as SDA input
    sdaDirSwitch_ = -1; // SDA direction switch disabled
    sclDirSwitch_ = -1; // SCL direction disabled
 
    erms_[0] = '\0';
 
    lastClkState_ = -1;  // unknown
    lastState_ = 0x0;    // all lines zero
    ignoreAck_ = 0;      // consider acknowledge signal
    txStretching_ = 0;   // no clock stretching for write operations
    rxStretching_ = 1;   // clock stretching for read operations
  }

  int Start_() {
    int buf[2];
    buf[0] = (0x1 << sda_) | (0x1 << scl_);
    buf[1] = (0x0 << sda_) | (0x1 << scl_);
    return (Out_(buf, 2));
  }

  int Stop_() {
    int buf[2];
    buf[0] = (0x0 << sda_) | (0x1 << scl_);
    buf[1] = (0x1 << sda_) | (0x1 << scl_);
    return (Out_(buf, 2));
  }

  int SendByte_(const int *buf) {
    int a;
    int res;
 
    /*
     * Send the 8 bits
     */
    res = Out_(buf, 8 * 3, txStretching_);
    if (res != 0)
      {
      return (res);
      }
 
    /*
     * Read the acknowledge bit
     */
    res = GetAck_(&a);
    if (res != 0)
      {
      return (res);
      }
 
    if (a)
      {
      /*
       * Ack is high - we have to stop
       */
      res = Stop_();
      if (res != 0)
    {
    return (res);
    }
      else
    {
    sprintf(ErrMsg(), "no acknowledge from slave-device");
    return (ngcbI2C_ERR_ACK);
    }
      }
 
    return (0);
  }

  int RecvByte_(char *byte, int last=0) {
    int d;
    int buf[3];
    int res;
    int i;
    int ds = 0;
 
    if (sdaDirSwitch_ >= 0)
      {
      /*
       * Switch SDA direction
       */
      ds = 1 << sdaDirSwitch_;
      buf[0] = (0x1 << sda_) | (0x0 << scl_) | ds;
      res = Out_(buf, 1);
      if (res != 0)
    {
    return (res);
    }
      }
 
    *byte = 0;
    for (i=7;i>=0;i--)
      {
      /*
       * Issue clock pulse
       */
      buf[0] = (0x1 << sda_) | (0x0 << scl_) | ds;
      buf[1] = (0x1 << sda_) | (0x1 << scl_) | ds;      
      res = Out_(buf, 2, rxStretching_);
      if (res != 0)
    {
    return (res);
    }
 
      /*
       * Read data
       */
      res = In_(&d);
      if (res != 0)
    {
    return (res);
    }
 
      /*
       * Last edge on clock-line
       */
      buf[0] = (0x1 << sda_) | (0x0 << scl_) | ds;
      res = Out_(buf, 1);
      if (res != 0)
    {
    return (res);
    }
 
      /*
       * Shift data bit to correct position
       */
      *byte |= (char)(((d >> sdaIn_) & 0x1) << i);
      }
 
    if (sdaDirSwitch_ >= 0)
      {
      /*
       * Switch back SDA direction
       */
      buf[0] = (0x1 << sda_) | (0x0 << scl_);
      res = Out_(buf, 1);
      if (res != 0)
    {
    return (res);
    }
      }
 
    if (!last)
      {
      /*
       * Issue acknowledge (hold data-line low)
       */
      buf[0] = (0x0 << sda_) | (0x0 << scl_);
      buf[1] = (0x0 << sda_) | (0x1 << scl_);      
      buf[2] = (0x0 << sda_) | (0x0 << scl_);      
      }
    else
      {
      /*
       * Deny acknowledge (release data-line)
       */
      buf[0] = (0x1 << sda_) | (0x0 << scl_);
      buf[1] = (0x1 << sda_) | (0x1 << scl_);      
      buf[2] = (0x1 << sda_) | (0x0 << scl_);      
      }
    res = Out_(buf, 3, txStretching_);
    if (res != 0)
      {
      return (res);
      }
 
    return (0);
  }

  int GetAck_(int *a) {
    int buf[2];
    int res;
 
    /*
     * Release data-line and issue clock pulse. Unless the
     * acknowledge signal is ignored we have to consider 
     * clock-stretching (if enabled) 
     */
    buf[0] = (0x1 << sda_) | (0x0 << scl_);
    buf[1] = (0x1 << sda_) | (0x1 << scl_);
    res = Out_(buf, 2, (!ignoreAck_ && rxStretching_) || txStretching_);
    if (res != 0)
      {
      return (res);
      }
 
    if (!ignoreAck_)
      {
      if ((sdaDirSwitch_ >= 0) && ((ackIn_ == sdaIn_) || (ackIn_ == sda_)))
    {
    /*
     * Switch SDA direction to read the acknowledge signal
     */
    buf[0] = (0x1 << sda_) | (0x1 << scl_) | (1 << sdaDirSwitch_);
    res = Out_(buf, 1);
    if (res != 0)
      {
      return (res);
      }
    }
 
      /*
       * Read actual state
       */
      res = In_(a, ackIn_);
      if (res != 0)
    {
    return (res);
    }
      }
    else
      {
      /*
       * We assume the acknowledge signal was there
       */
      *a = 0;
      }
 
    /*
     * Last edge on clock-line
     */
    buf[0] = (0x1 << sda_) | (0x0 << scl_);
    res = Out_(buf, 1);
    if (res != 0)
      {
      return (res);
      }
 
    return (0);
  }

  int Out_(const int *buf, int size, int doStretching=0) {
    int i, r;
 
    for (i=0;i<size;i++)
      {
      /*
       * Send new state
       */
      if (OutCB(buf[i], &r, erms_) != 0)
    {
    lastClkState_ = -1;
    return (r);
    }
 
      /*
       * Always save last state (here we use the full word to
       * have it for whatever purpose)
       */
      lastState_ = buf[i];
 
      if (doStretching && (clkStretchCnt_ > 0))
    {
    int thisClkState = (buf[i] >> scl_) & 0x1;
 
    if ((lastClkState_ == 0) && (thisClkState == 1))
      {
      int b = 0;
      int cnt = 0;
 
      if (sclDirSwitch_ >= 0)
        {
        /*
         * Switch SCL direction to read the clock-line signal
         */
        if (OutCB(lastState_ | (1 << sclDirSwitch_), &r, erms_) != 0)
          {
          lastClkState_ = -1;
          return (r);
          }
        }
 
      /*
       * Poll for clock high
       */
      while (!((b >> sclIn_) & 0x1) && (cnt < clkStretchCnt_))
        {
        if (InCB(&b, &r, erms_) != 0)
          {
          return (r);
          }
 
        cnt++;
        if (cnt >= clkStretchCnt_)
          {
          sprintf(ErrMsg(), "clock line is forced low");
          return (ngcbI2C_ERR_CLK);
          }
 
        // delay (TBD)
        }
 
      if (sclDirSwitch_ >= 0)
        {
        /*
         * Switch back SCL direction
         */
        if (OutCB(lastState_, &r, erms_) != 0)
          {
          lastClkState_ = -1;
          return (r);
          }
        }
      }
    }
      
      /*
       * Save last clock state
       */
      lastClkState_ = (buf[i] >> scl_) & 0x1;
      }
 
    return (0);
  }
  
  int In_(int *d) {return (In_(d, sdaIn_));}

  int In_(int *d, int line) {
    int b, r;
 
    /*
     * Read actual state
     */
    if (InCB(&b, &r, erms_) != 0)
      {
      *d = 0;
      return (r);
      }
 
    /*
     * Get data bit
     */
    *d = (b >> line) & 0x1;
 
    return (0);
  }

  void Int2Bin_(char *str, int in) {
    int x = in;
    int i;
    
    for (i=0;i<32;i++)
      {
      if ((x & 0x00000001) == 1) str[31 - i]='1';
      else str[31 - i]='0';
      x = x >> 1;
      }
    str[32] = '\0';
  }
 
};
 
 
#endif