TWI.hh

Go to the documentation of this file.

#ifndef COSA_USI_TWI_HH
#define COSA_USI_TWI_HH

#include "Cosa/Types.h"
#if defined(BOARD_ATTINY)
#include "Cosa/IOPin.hh"
#include "Cosa/Event.hh"
#include "Cosa/Power.hh"
class TWI {
public:
  class Driver {
  public:
   Driver(uint8_t addr) :
     m_addr(addr << 1),
     m_async(false)
    {}

    bool is_async() const
    {
      return (m_async);
    }

    void sync_request()
    {
      m_async = false;
    }

    void async_request()
    {
      m_async = true;
    }

    virtual void on_completion(uint8_t type, int count)
    {
      UNUSED(type);
      UNUSED(count);
    }

  protected:
    uint8_t m_addr;

    bool m_async;

    friend class TWI;
    friend void ::USI_START_vect(void);
    friend void ::USI_OVF_vect(void);
  };

  class Slave : public Driver, public Event::Handler {
  public:
    Slave(uint8_t addr) : TWI::Driver(addr), Event::Handler() {}

    void read_buf(void* buf, size_t size);

    void write_buf(void* buf, size_t size);

    void begin();

    virtual void on_completion(uint8_t type, int count)
    {
      Event::push(type, this, count);
    }

    virtual void on_request(void* buf, size_t size) = 0;

  protected:
    virtual void on_event(uint8_t type, uint16_t value);

    friend void ::USI_START_vect(void);
    friend void ::USI_OVF_vect(void);
  };

  TWI();

  void acquire(TWI::Driver* dev);

  void release();

  int write(void* buf, size_t size);

  int write(uint8_t header, void* buf = 0, size_t size = 0);

  int write(uint16_t header, void* buf = 0, size_t size = 0);

  int read(void* buf, size_t size);

  void set_freq(uint32_t hz)
  {
    UNUSED(hz);
  }

  void powerup()
  {
    power_usi_enable();
  }

  void powerdown()
  {
    power_usi_disable();
  }

private:
  enum State {
    // Idle, waiting for start condition
    IDLE,
    // Check start condition
    START_CHECK,
    // Slave transmission states (Master read operation)
    READ_REQUEST,
    READ_COMPLETED,
    ACK_CHECK,
    // Slave receiver states (Master write operation)
    WRITE_REQUEST,
    WRITE_COMPLETED,
    // Slave service state (Response to write)
    SERVICE_REQUEST
  } __attribute__((packed));

  enum {
    WRITE_OP = 0x00,            
    READ_OP = 0x01,             
    ADDR_MASK = 0xfe            
  } __attribute__((packed));

  enum {
    // Clear all interrupt flags
    SR_CLEAR_ALL = _BV(USISIF) | _BV(USIOIF) | _BV(USIPF) | _BV(USIDC),
    // Clear all flags, except Start Condition.
    SR_CLEAR = _BV(USIOIF) | _BV(USIPF) | _BV(USIDC),
    // Clear flags. Set USI counter to shift 1 bit (2 edges)
    SR_CLEAR_ACK = SR_CLEAR | (0x0E << USICNT0),
    // Clear flags. Set USI counter to shift 8 bits (16 edges)
    SR_CLEAR_DATA = SR_CLEAR | (0x0 << USICNT0),
    // Set USI TWI mode(0). External clock source
    CR_SERVICE_MODE = _BV(USIWM1) |  _BV(USICS1),
    // Enable start condition. Set USI TWI mode(0). External clock source
    CR_START_MODE = _BV(USISIE) | _BV(USIWM1) |  _BV(USICS1),
    // Enable start and overflow. Set USI TWI mode(1). External clock
    CR_TRANSFER_MODE = _BV(USISIE) |  _BV(USIOIE) | _BV(USIWM1) | _BV(USIWM0)
                     | _BV(USICS1),
    // Master initialization. Software clock strobe
    CR_INIT_MODE =  _BV(USIWM1) | _BV(USICS1) | _BV(USICLK),
    // Master data transfer. Software clock strobe
    CR_DATA_MODE = _BV(USIWM1) | _BV(USICS1) | _BV(USICLK) | _BV(USITC)
  } __attribute__((packed));

  static const uint8_t HEADER_MAX = 4;
  static const uint8_t VEC_MAX = 4;
  static const uint8_t WRITE_IX = 0;
  static const uint8_t READ_IX = 1;
  uint8_t m_header[HEADER_MAX];
  iovec_t m_vec[VEC_MAX];
  IOPin m_sda;
  IOPin m_scl;
  volatile State m_state;
  volatile uint8_t* m_next;
  volatile uint8_t* m_last;
  volatile int m_count;
  Driver* m_dev;
  volatile bool m_busy;

  State state() const
  {
    return (m_state);
  }

  void state(State state)
  {
    m_state = state;
  }

  void mode(IOPin::Mode mode)
  {
    m_sda.mode(mode);
    if (mode == IOPin::INPUT_MODE) m_sda.set();
  }

  void buf(uint8_t ix)
  {
    if (ix > VEC_MAX) return;
    m_next = (uint8_t*) m_vec[ix].buf;
    m_last = m_next + m_vec[ix].size;
    m_count = 0;
  }

  uint8_t available()
  {
    return (m_last - m_next);
  }

  bool put(uint8_t data)
  {
    *m_next++ = data;
    m_count += 1;
    return (m_next < m_last);
  }

  bool get(uint8_t& data)
  {
    if (m_next == m_last) return (false);
    data = *m_next++;
    m_count += 1;
    return (true);
  }

  bool start();

  uint8_t transfer(uint8_t data, uint8_t bits = CHARBITS);

  bool stop();

  int request(uint8_t op);

  friend void ::USI_START_vect(void);
  friend void ::USI_OVF_vect(void);
};
#endif
#endif