SPI.h

Go to the documentation of this file.

#ifndef SPI_H
#define SPI_H

#include "GPIO.h"

class SPI {
public:
  static const uint32_t MAX_FREQ = F_CPU / 2;

  SPI() : m_busy(false) {}

  virtual uint8_t prescale(uint32_t frequency)
  {
    return (F_CPU / frequency);
  }

  virtual void acquire(uint8_t mode, uint8_t bitorder, uint8_t prescale)
  {
    (void) mode;
    (void) bitorder;
    (void) prescale;
    lock();
  }

  virtual void release()
  {
    unlock();
  }

  virtual uint8_t transfer(uint8_t value) = 0;

  SPI& operator>>(uint8_t& value)
    __attribute__((always_inline))
  {
    value = transfer(0);
    return (*this);
  }

  SPI& operator<<(uint8_t value)
    __attribute__((always_inline))
  {
    transfer(value);
    return (*this);
  }

  virtual void transfer(void* dest, const void* src, size_t count)
  {
    if (count == 0 || dest == NULL || src == NULL) return;
    const uint8_t* sp = (const uint8_t*) src;
    uint8_t* dp = (uint8_t*) dest;
    do *dp++ = transfer(*sp++); while (--count);
  }

  virtual void read(void* buf, size_t count)
  {
    if (count == 0 || buf == NULL) return;
    uint8_t* bp = (uint8_t*) buf;
    do *bp++ = transfer(0); while (--count);
  }

  virtual void write(const void* buf, size_t count)
  {
    if (count == 0 || buf == NULL) return;
    uint8_t* bp = (uint8_t*) buf;
    do transfer(*bp++); while (--count);
  }

  template<uint8_t MODE, uint8_t BITORDER, uint32_t FREQ, BOARD::pin_t SS_PIN>
  class Device {
  public:
    Device(SPI& spi, bool ss = HIGH) :
      m_spi(spi),
      PRESCALE(spi.prescale(FREQ))
    {
      m_ss.output();
      m_ss = ss;
    }

    void acquire()
      __attribute__((always_inline))
    {
      m_spi.acquire(MODE, BITORDER, PRESCALE);
      m_ss.toggle();
    }

    void release()
      __attribute__((always_inline))
    {
      m_ss.toggle();
      m_spi.release();
    }

    uint8_t transfer(uint8_t value)
      __attribute__((always_inline))
    {
      return (m_spi.transfer(value));
    }

    void transfer(void* dest, const void* src, size_t count)
      __attribute__((always_inline))
    {
      m_spi.transfer(dest, src, count);
    }

    void read(void* buf, size_t count)
      __attribute__((always_inline))
    {
      m_spi.read(buf, count);
    }

    void write(const void* buf, size_t count)
      __attribute__((always_inline))
    {
      m_spi.write(buf, count);
    }

  protected:
    SPI& m_spi;

    GPIO<SS_PIN> m_ss;

    const uint8_t PRESCALE;
  };

protected:
  volatile bool m_busy;

  void lock()
    __attribute__((always_inline))
  {
    while (m_busy) yield();
    m_busy = true;
  }

  void unlock()
    __attribute__((always_inline))
  {
    m_busy = false;
  }
};
#endif