SPIBase.h

Go to the documentation of this file.

/*
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * SPIBase.h
 *
 *  Created on: Mar 2, 2016
 *      Author: harry-boe
 *
 */
 
#pragma once
 
#include "SPISettings.h"
#include <cstddef>
 
// for compatibility when porting from Arduino
#define SPI_HAS_TRANSACTION 1
 
static constexpr uint8_t SPI_PIN_DEFAULT{0xff};
 
struct SpiPins {
    uint8_t sck{SPI_PIN_DEFAULT};
    uint8_t miso{SPI_PIN_DEFAULT};
    uint8_t mosi{SPI_PIN_DEFAULT};
 
    bool operator==(const SpiPins& other) const
    {
        return sck == other.sck && miso == other.miso && mosi == other.mosi;
    }
};
 
/*
 * @brief Base class/interface for SPI implementations
 */
class SPIBase
{
public:
    SPIBase(const SpiPins& pins) : mPins(pins)
    {
    }
 
    virtual ~SPIBase() = default;
 
    virtual bool begin() = 0;
 
    virtual void end() = 0;
 
    void beginTransaction(SPISettings& settings)
    {
        prepare(settings);
    }
 
    void beginTransaction(const SPISettings& settings)
    {
        SPISettings tmp{settings};
        prepare(tmp);
    }
 
    virtual void endTransaction()
    {
    }
 
    void write(uint8_t data)
    {
        transfer(data);
    }
 
    void write16(uint16_t data)
    {
        transfer16(data);
    }
 
    void write32(uint32_t data)
    {
        transfer32(data);
    }
 
    virtual uint8_t read8()
    {
        return transfer(0xff);
    }
 
    uint8_t transfer(uint8_t val)
    {
        return transfer32(val, 8);
    }
 
    uint16_t transfer16(uint16_t val)
    {
        return transfer32(val, 16);
    }
 
    virtual uint32_t transfer32(uint32_t val, uint8_t bits = 32)
    {
        transfer(reinterpret_cast<uint8_t*>(&val), bits / 8);
        return val;
    }
 
    virtual void transfer(uint8_t* buffer, size_t size) = 0;
 
    virtual bool loopback(bool enable) = 0;
 
    SPISettings SPIDefaultSettings;
 
    const SpiPins& pins{mPins};
 
protected:
    virtual void prepare(SPISettings& settings) = 0;
 
    void assignDefaultPins(const SpiPins& defPins)
    {
        if(pins.sck == SPI_PIN_DEFAULT) {
            mPins.sck = defPins.sck;
        }
        if(pins.miso == SPI_PIN_DEFAULT) {
            mPins.miso = defPins.miso;
        }
        if(pins.mosi == SPI_PIN_DEFAULT) {
            mPins.mosi = defPins.mosi;
        }
    }
 
    SpiPins mPins;
};