SPI.h

Go to the documentation of this file.

/*
    SPI.h - an interface to the SPI subsystem of the
    AVR ATMega328p (Arduino Uno) and ATMega2560 (Arduino Mega).
    This is part of the AVRTools library.
    Copyright (c) 2015 Igor Mikolic-Torreira.  All right reserved.
    Various portions of this code adapted from Arduino SPI code that
    is Copyright (c) 2010 by Cristian Maglie, Copyright (c) 2014 by Paul Stoffregen,
    Copyright (c) 2014 by Matthijs Kooijman, and Copyright (c) 2014 by Andrew J. Kroll
    and licensed under the terms of either the GNU General Public License version 2
    or the GNU Lesser General Public License version 2.1.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
 
#ifndef SPI_h
#define SPI_h
 
#include <stdint.h>
#include <stddef.h>
 
#include <avr/io.h>
 
 
namespace SPI
{
 
    enum ByteOrder
    {
        kLsbFirst    = 0,   
        kMsbFirst    = 1    
    };
 
 
    enum SpiMode
    {
        kSpiMode0   = 0x00,   
        kSpiMode1   = 0x04,   
        kSpiMode2   = 0x08,   
        kSpiMode3   = 0x0C    
    };
 
 
    class SPISettings
    {
    public:
 
        SPISettings( uint32_t maxSpeed, uint8_t bitOrder, uint8_t dataMode )
        {
            if ( __builtin_constant_p( maxSpeed ) )
            {
                initAlwaysInline( maxSpeed, bitOrder, dataMode );
            }
            else
            {
                initMightInline( maxSpeed, bitOrder, dataMode );
            }
        }
 
 
 
        SPISettings()
        {
            initAlwaysInline( 8000000, kMsbFirst, kSpiMode0 );
        }
 
 
 
        uint8_t getSpcr() const
        {
            return mSpcr;
        }
 
 
        uint8_t getSpsr() const
        {
            return mSpsr;
        }
 
 
 
 
 
    private:
 
 
        void initMightInline( uint32_t maxSpeed, uint8_t bitOrder, uint8_t dataMode )
        {
            initAlwaysInline( maxSpeed, bitOrder, dataMode );
        }
 
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-variable"
 
        void initAlwaysInline( uint32_t maxSpeed, uint8_t bitOrder, uint8_t dataMode )  __attribute__((__always_inline__))
        {
            /*
            * The following are internal constants
            */
            const uint8_t kSpiClockDiv4     = 0x00;
            const uint8_t kSpiClockDiv16    = 0x01;
            const uint8_t kSpiClockDiv64    = 0x02;
            const uint8_t kSpiClockDiv128   = 0x03;
            const uint8_t kSpiClockDiv2     = 0x04;
            const uint8_t kSpiClockDiv8     = 0x05;
            const uint8_t kSpiClockDiv32    = 0x06;
 
            const uint8_t kSpiModeMask      = 0x0C;   // CPOL = bit 3, CPHA = bit 2 on SPCR
            const uint8_t kSpiClockMask     = 0x03;   // SPR1 = bit 1, SPR0 = bit 0 on SPCR
            const uint8_t kSpi2xClockMask   = 0x01;   // SPI2X = bit 0 on SPSR
 
 
            // Clock settings are defined as follows. Note that this shows SPI2X
            // inverted, so the bits form increasing numbers. Also note that
            // fosc/64 appears twice
            // SPR1 SPR0 ~SPI2X Freq
            //   0    0     0   fosc/2
            //   0    0     1   fosc/4
            //   0    1     0   fosc/8
            //   0    1     1   fosc/16
            //   1    0     0   fosc/32
            //   1    0     1   fosc/64
            //   1    1     0   fosc/64
            //   1    1     1   fosc/128
 
            // We find the fastest clock that is less than or equal to the
            // given clock rate. The clock divider that results in clock_setting
            // is 2 ^^ (clock_div + 1). If nothing is slow enough, we'll use the
            // slowest (128 == 2 ^^ 7, so clock_div = 6).
            uint8_t clockDiv;
 
            // When the clock is known at compile time, use this if-then-else
            // cascade, which the compiler knows how to completely optimize
            // away. When clock is not known, use a loop instead, which generates
            // shorter code.
            if ( __builtin_constant_p( maxSpeed ) )
            {
                if ( maxSpeed >= F_CPU / 2 )
                {
                    clockDiv = 0;
                }
                else if ( maxSpeed >= F_CPU / 4 )
                {
                    clockDiv = 1;
                }
                else if ( maxSpeed >= F_CPU / 8 )
                {
                    clockDiv = 2;
                }
                else if ( maxSpeed >= F_CPU / 16 )
                {
                    clockDiv = 3;
                }
                else if ( maxSpeed >= F_CPU / 32 )
                {
                    clockDiv = 4;
                }
                else if ( maxSpeed >= F_CPU / 64 )
                {
                    clockDiv = 5;
                }
                else
                {
                    clockDiv = 6;
                }
            }
            else
            {
                uint32_t clockSetting = F_CPU / 2;
                clockDiv = 0;
                while ( clockDiv < 6 && maxSpeed < clockSetting )
                {
                    clockSetting /= 2;
                    clockDiv++;
                }
            }
 
            // Compensate for the duplicate fosc/64
            if ( clockDiv == 6 )
            {
                clockDiv = 7;
            }
 
            // Invert the SPI2X bit
            clockDiv ^= 0x1;
 
            // Pack into the SPISettings class
            mSpcr = _BV(SPE)
                    | _BV(MSTR)
                    | ( (bitOrder == kLsbFirst) ? _BV(DORD) : 0 )
                    | ( dataMode & kSpiModeMask )
                    | ( (clockDiv >> 1) & kSpiClockMask );
 
            mSpsr = clockDiv & kSpi2xClockMask;
        }
 
#pragma GCC diagnostic pop
 
 
        uint8_t mSpcr;
        uint8_t mSpsr;
    };
 
 
 
 
    void enable();
 
 
 
    void disable();
 
 
    inline void configure( SPISettings settings )
    {
        SPCR = settings.getSpcr();
        SPSR = settings.getSpsr();
    }
 
 
    inline uint8_t transmit( uint8_t data )
    {
        SPDR = data;
        /*
        * The following NOP introduces a small delay that can prevent the wait
        * loop from iterating when running at the maximum speed. This gives
        * about 10% more speed, even if it seems counter-intuitive. At lower
        * speeds it is unnoticed.
        */
        asm volatile( "nop" );
        while ( !( SPSR & _BV(SPIF) ) )
            ; // wait
        return SPDR;
    }
 
 
    inline uint16_t transmit16( uint16_t data )
    {
        union
        {
            uint16_t val;
            struct
            {
                uint8_t lsb;
                uint8_t msb;
 
            };
        } in, out;
 
        in.val = data;
 
        if ( SPCR & _BV(DORD) )
        {
            SPDR = in.lsb;
            asm volatile( "nop" );              // See transmit( uint8_t ) function
            while ( !( SPSR & _BV(SPIF) ) )
                ;
            out.lsb = SPDR;
 
            SPDR = in.msb;
            asm volatile( "nop" );
            while ( !( SPSR & _BV(SPIF) ) )
                ;
            out.msb = SPDR;
        }
        else
        {
            SPDR = in.msb;
            asm volatile( "nop" );                // See transmit( uint8_t ) function
            while ( !( SPSR & _BV(SPIF) ) )
                ;
            out.msb = SPDR;
            SPDR = in.lsb;
            asm volatile( "nop" );
            while ( !( SPSR & _BV(SPIF) ) )
                ;
            out.lsb = SPDR;
        }
 
        return out.val;
    }
 
 
    uint32_t transmit32( uint32_t data );
 
 
 
    inline void transmit( uint8_t* buffer, size_t count )
    {
        if ( count )
        {
            uint8_t* p = buffer;
            SPDR = *p;
 
            while ( --count > 0 )
            {
                uint8_t out = *(p + 1);
                while ( !( SPSR & _BV(SPIF) ) )
                    ;
                uint8_t in = SPDR;
                SPDR = out;
                *p++ = in;
            }
 
            while ( !(SPSR & _BV(SPIF) ) )
                ;
            *p = SPDR;
        }
    }
 
 
}   // End namespace
 
#endif