SdSpiBareUnoDriver.h

Go to the documentation of this file.

 
#ifndef SdSpiBareUnoDriver_h
#define SdSpiBareUnoDriver_h
#include "../common/SysCall.h"
#include <avr/interrupt.h>
#define nop asm volatile("nop\n\t")
#ifndef HIGH
#define HIGH 1
#endif // HIGH
#ifndef LOW
#define LOW 0
#endif // LOW
#ifndef INPUT
#define INPUT 0
#endif // INPUT
#ifndef OUTPUT
#define OUTPUT 1
#endif // OUTPUT
 
inline uint8_t unoBit(uint8_t pin)
{
    return 1 << (pin < 8 ? pin : pin < 14 ? pin - 8 : pin - 14);
}
inline uint8_t unoDigitalRead(uint8_t pin)
{
    volatile uint8_t *reg = pin < 8 ? &PIND : pin < 14 ? &PINB : &PINC;
    return *reg & unoBit(pin);
}
inline void unoDigitalWrite(uint8_t pin, uint8_t value)
{
    volatile uint8_t *port = pin < 8 ? &PORTD : pin < 14 ? &PORTB : &PORTC;
    uint8_t bit = unoBit(pin);
    cli();
    if (value)
    {
        *port |= bit;
    }
    else
    {
        *port &= ~bit;
    }
    sei();
}
 
inline void unoPinMode(uint8_t pin, uint8_t mode)
{
    uint8_t bit = unoBit(pin);
    volatile uint8_t *reg = pin < 8 ? &DDRD : pin < 14 ? &DDRB : &DDRC;
 
    cli();
    if (mode == OUTPUT)
    {
        *reg |= bit;
    }
    else
    {
        *reg &= ~bit;
        // handle INPUT pull-up
        unoDigitalWrite(pin, mode != INPUT);
    }
    sei();
}
 
#define UNO_SS   10
#define UNO_MOSI 11
#define UNO_MISO 12
#define UNO_SCK  13
//------------------------------------------------------------------------------
class SdSpiDriverBareUno
{
  public:
    void activate()
    {
    }
    void end()
    {
    }
    void deactivate()
    {
    }
    void begin(SdSpiConfig spiConfig)
    {
        m_csPin = spiConfig.csPin;
        unoPinMode(m_csPin, OUTPUT);
        unoDigitalWrite(m_csPin, HIGH);
        unoDigitalWrite(UNO_SS, HIGH);
        unoPinMode(UNO_SS, OUTPUT);
        SPCR |= _BV(MSTR);
        SPCR |= _BV(SPE);
        SPSR = 0;
        unoPinMode(UNO_SCK, OUTPUT);
        unoPinMode(UNO_MOSI, OUTPUT);
    }
    uint8_t receive()
    {
        return transfer(0XFF);
    }
    uint8_t receive(uint8_t *buf, size_t count)
    {
        if (count == 0)
        {
            return 0;
        }
        uint8_t *pr = buf;
        SPDR = 0XFF;
        while (--count > 0)
        {
            while (!(SPSR & _BV(SPIF)))
            {
            }
            uint8_t in = SPDR;
            SPDR = 0XFF;
            *pr++ = in;
            // nops to optimize loop for 16MHz CPU 8 MHz SPI
            nop;
            nop;
        }
        while (!(SPSR & _BV(SPIF)))
        {
        }
        *pr = SPDR;
        return 0;
    }
    void send(uint8_t data)
    {
        transfer(data);
    }
    void send(const uint8_t *buf, size_t count)
    {
        if (count == 0)
        {
            return;
        }
        SPDR = *buf++;
        while (--count > 0)
        {
            uint8_t b = *buf++;
            while (!(SPSR & (1 << SPIF)))
            {
            }
            SPDR = b;
            // nops to optimize loop for 16MHz CPU 8 MHz SPI
            nop;
            nop;
        }
        while (!(SPSR & (1 << SPIF)))
        {
        }
    }
    void select()
    {
        unoDigitalWrite(m_csPin, LOW);
    }
    void setSckSpeed(uint32_t maxSck)
    {
        (void)maxSck;
        SPSR |= 1 << SPI2X;
    }
    static uint8_t transfer(uint8_t data)
    {
        SPDR = data;
        while (!(SPSR & _BV(SPIF)))
        {
        } // wait
        return SPDR;
    }
    void unselect()
    {
        unoDigitalWrite(m_csPin, HIGH);
    }
 
  private:
    SdCsPin_t m_csPin;
};
#endif // SdSpiBareUnoDriver_h