TWI.h

Go to the documentation of this file.

#ifndef SOFTWARE_TWI_H
#define SOFTWARE_TWI_H

#include "TWI.h"
#include "GPIO.h"

namespace Software {
template<BOARD::pin_t SDA_PIN, BOARD::pin_t SCL_PIN>
class TWI : public ::TWI {
public:
  TWI()
  {
    m_sda.open_drain();
    m_scl.open_drain();
  }

  virtual bool acquire()
  {
    while (m_busy) yield();
    m_busy = true;
    m_start = true;
    return (start_condition());
  }

  virtual bool release()
  {
    m_start = false;
    m_busy = false;
    return (stop_condition());
  }

  virtual int read(uint8_t addr, void* buf, size_t count)
  {
    // Check if repeated start condition should be generated
    if (!m_start && !repeated_start_condition()) return (-1);
    m_start = false;

    // Address device with read request and check that it acknowledges
    bool nack;
    if (!write_byte(addr | 1, nack) || nack) return (-1);

    // Read bytes and acknowledge until required size
    uint8_t* bp = (uint8_t*) buf;
    size_t size = count;
    while (size--) {
      bool ack = (size != 0);
      uint8_t data;
      if (!read_byte(data, ack)) return (-1);
      *bp++ = data;
    }
    return (count);
  }

  virtual int write(uint8_t addr, iovec_t* vp)
  {
    // Check if repeated start condition should be generated
    if (!m_start && !repeated_start_condition()) return (-1);
    m_start = false;

    // Address device with write request and check that it acknowledges
    bool nack;
    if (!write_byte(addr | 0, nack) || nack) return (-1);
    if (vp == NULL) return (0);

    // Write given io vector buffers to device
    int count = 0;
    for(; vp->buf != NULL; vp++) {
      const uint8_t* bp = (const uint8_t*) vp->buf;
      size_t size = vp->size;
      count += size;
      while (size--) {
        uint8_t data = *bp++;
        if (!write_byte(data, nack) || nack) return (-1);
      }
    }
    return (count);
  }

protected:
  static const int T1 = 4;

  static const int T2 = 5;

  static const int CLOCK_STRETCHING_RETRY_MAX = 25;

  GPIO<SDA_PIN> m_sda;

  GPIO<SCL_PIN> m_scl;

  bool m_start;

  bool clock_stretching()
  {
    for (int retry = 0; retry < CLOCK_STRETCHING_RETRY_MAX; retry++) {
      if (m_scl) return (true);
      delayMicroseconds(T1);
    }
    return (false);
  }

  bool start_condition()
  {
    m_sda.input();
    if (m_sda == 0) return (false);
    m_sda.output();
    delayMicroseconds(T1);
    m_scl.output();
    return (true);
  }

  bool repeated_start_condition()
  {
    delayMicroseconds(T1);
    m_sda.input();
    if (m_sda == 0) return (false);
    m_scl.input();
    delayMicroseconds(T2);
    m_sda.output();
    delayMicroseconds(T1);
    m_scl.output();
    return (true);
  }

  bool stop_condition()
  {
    delayMicroseconds(T1);
    m_sda.output();
    m_scl.input();
    delayMicroseconds(T1);
    if (!clock_stretching()) return (false);
    m_sda.input();
    return (m_sda == 0);
  }

  bool write_bit(bool value)
  {
    if (value) m_sda.input(); else m_sda.output();
    delayMicroseconds(T2);
    m_scl.input();
    delayMicroseconds(T1);
    if (!clock_stretching()) return (false);
    m_scl.output();
    return (true);
  }

  bool read_bit(bool& value)
  {
    m_sda.input();
    delayMicroseconds(T2);
    m_scl.input();
    delayMicroseconds(T1);
    if (!clock_stretching()) return (false);
    value = m_sda;
    m_scl.output();
    return (true);
  }

  bool write_byte(uint8_t byte, bool& nack)
  {
    for (int i = 0; i < 8; i++) {
      if (!write_bit(byte & 0x80)) return (false);
      byte <<= 1;
    }
    return (read_bit(nack));
  }

  bool read_byte(uint8_t& byte, bool ack)
  {
    bool value;
    byte = 0;
    for (int i = 0; i < 8; i++) {
      if (!read_bit(value)) return (false);
      byte = (byte << 1) | value;
    }
    return (write_bit(!ack));
  }
};
};
#endif