HardwareSPI.h

Go to the documentation of this file.

 
#ifndef _SPI_H_INCLUDED
#define _SPI_H_INCLUDED
 
#include "HardwareCRC.h"
 
//Includes
#if defined(STM32F103xB)
//#include "stm32f1xx_hal.h"
 
#define IS_SPI_INSTANCE_ON_APB1(_instance_) ((_instance_) == SPI2)
#define IS_SPI_INSTANCE_ON_APB2(_instance_) ((_instance_) == SPI1)
 
#elif defined(STM32F031x6) || defined(STM32F070xB) || defined(STM32F070x6) || defined(STM32F030x6)
//#include "stm32f0xx_hal.h"
 
//#define IS_SPI_INSTANCE_ON_APB2(_instance_)
#define IS_SPI_INSTANCE_ON_APB1(_instance_) ((_instance_) == SPI1)
 
#elif defined(STM32L031xx)
//#include "stm32l0xx_hal.h"
 
//#define IS_SPI_INSTANCE_ON_APB1(_instance_)
#define IS_SPI_INSTANCE_ON_APB2(_instance_) ((_instance_) == SPI1)
 
#elif defined(STM32L432xx)
//#include "stm32l4xx_hal.h"
 
#define IS_SPI_INSTANCE_ON_APB1(_instance_) ((_instance_) == SPI3)
#define IS_SPI_INSTANCE_ON_APB2(_instance_) ((_instance_) == SPI1)
 
#else
#error "Definitions for your MCU are not defined."
#endif
 
#if defined(HAL_SPI_MODULE_ENABLED) || defined(DOXYGEN_FORCED)
 
#define SPI_HAS_TRANSACTION 1
 
#define SPI_CLOCK_DIV2      SPI_BAUDRATEPRESCALER_2
#define SPI_CLOCK_DIV4      SPI_BAUDRATEPRESCALER_4
#define SPI_CLOCK_DIV8      SPI_BAUDRATEPRESCALER_8
#define SPI_CLOCK_DIV16     SPI_BAUDRATEPRESCALER_16
#define SPI_CLOCK_DIV32     SPI_BAUDRATEPRESCALER_32
#define SPI_CLOCK_DIV64     SPI_BAUDRATEPRESCALER_64
#define SPI_CLOCK_DIV128    SPI_BAUDRATEPRESCALER_128
#define SPI_CLOCK_DIV256    SPI_BAUDRATEPRESCALER_256
 
const uint8_t SPI_MODE0 = 0x00; 
const uint8_t SPI_MODE1 = 0x01; 
const uint8_t SPI_MODE2 = 0x10; 
const uint8_t SPI_MODE3 = 0x11; 
 
#define SPI_MASTER SPI_MODE_MASTER
#define SPI_SLAVE  SPI_MODE_SLAVE
 
typedef enum{
    SPI_OK = HAL_OK,
    SPI_ERR = HAL_ERROR,
    SPI_BUSY_ERR = HAL_BUSY,
    SPI_TIMEOUT = HAL_TIMEOUT,
    SPI_GEN_ERR,
    SPI_ERR_LOCKED,
    SPI_CRC_ERR
 
}SPI_Status;
 
typedef enum{
    SPI_ERROR_NONE  = HAL_SPI_ERROR_NONE,
    SPI_ERROR_MODF  = HAL_SPI_ERROR_MODF,
    SPI_ERROR_CRC   = HAL_SPI_ERROR_CRC,
    SPI_ERROR_OVR   = HAL_SPI_ERROR_OVR,
#ifdef HAL_SPI_ERROR_FRE
 
    SPI_ERROR_FRE   = HAL_SPI_ERROR_FRE,
#endif
 
    SPI_ERROR_DMA   = HAL_SPI_ERROR_DMA,
    SPI_ERROR_FLAG  = HAL_SPI_ERROR_FLAG,
    SPI_ERROR_ABORT = HAL_SPI_ERROR_ABORT,
}SPI_ErrorCode;
 
typedef enum{
    SPI_CRC_DATAWIDTH = 0,
    SPI_CRC_1BYTE = 8,
    SPI_CRC_2BYTES = 16
}SPI_CRCLength;
 
 
class SPISettings {
public:
  SPISettings() :_clock(1000000), _bitOrder(MSBFIRST), _dataMode(SPI_MODE0){}
  SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode) :_clock(clock), _bitOrder(bitOrder), _dataMode(dataMode){}
  uint32_t _clock;
  uint8_t  _bitOrder;
  uint8_t  _dataMode;
};
 
class HardwareSPI {
public:
    HardwareSPI(SPI_HandleTypeDef &hspi);
 
    ~HardwareSPI();
 
    bool begin(SPI_InitTypeDef &initStruct);
 
    bool begin();
 
    bool end();
 //End of SPIInitMethods
 
    bool isSending(){
        return _hspi->State == HAL_SPI_STATE_BUSY_TX || _hspi->State == HAL_SPI_STATE_BUSY_TX_RX;
    }
 
    bool isReceiving(){
        return _hspi->State == HAL_SPI_STATE_BUSY_RX || _hspi->State == HAL_SPI_STATE_BUSY_TX_RX;
    }
 
    bool isTransfering(){
        return (_hspi->State == HAL_SPI_STATE_BUSY_TX_RX);
    }
 
    inline bool isTransacting(){
        return _hspi->State == HAL_SPI_STATE_BUSY_TX || _hspi->State == HAL_SPI_STATE_BUSY_TX_RX || _hspi->State == HAL_SPI_STATE_BUSY_RX;
    }
 
    bool instanceExists(void){
        return (&_hspi != NULL) && (IS_SPI_ALL_INSTANCE(_hspi->Instance));
    }
 
 
 //End of SPIStateMethods
 
    bool connectDMAtoRx(DMA_HandleTypeDef &DMA_handle);
 
    bool connectDMAtoTx(DMA_HandleTypeDef &DMA_handle);
 
    bool disconnectDMAfromRx();
 
    bool disconnectDMAfromTx();
 
    bool isDMAconnectedToRx(void);
 
    bool isDMAconnectedToTx(void);
 
    uint32_t getSPIClockFreq(void);
 
    bool setMode(uint32_t mode);
 
    uint32_t getMode();
 
    bool setHwCS(bool HardwareCS, bool OutputCS = true);
 
    bool isHwCS();
 
    bool isHwOutputCS();
 
    bool setBitOrder(uint8_t bitOrder);
 
    uint8_t getBitOrder();
 
    bool setDataMode(uint8_t dataMode);
 
    uint8_t getDataMode();
 
    bool setFrequency(uint32_t freq);
 
    uint32_t getFrequency();
 
    bool setClockDivider(uint32_t clockDiv);
 
    uint32_t getClockDivider();
 
    bool setDataBits(uint16_t bits);
 
    uint16_t getDataBits();
 
    bool enableTImode(bool enable);
 
    bool isTImodeEnabled();
 
    bool enableCRC(bool enable);
 
    bool isCRCenabled();
 
    bool setCRClength(SPI_CRCLength length);
 
    SPI_CRCLength getCRClength();
 
    bool setCRCPolynomial(uint32_t polynomial);
 
    uint32_t getCRCPolynomial();
 
    void setTimeout(uint32_t Timeout);
 
    uint32_t getTimeout();
 //End of SPISettingMethods
 
    virtual SPI_Status beginTransaction(SPISettings settings);
 
    void flushRX();
 
    bool flush();
 //End of SPITransactionInitMethods
 
    virtual uint16_t transfer(uint16_t data, bool lastByte = false);
 
    virtual uint16_t transfer16(uint16_t data, bool lastByte = false);
 
    virtual uint32_t transfer32(uint32_t data, bool lastByte = false);
 
    virtual bool transfer(void *buf, uint16_t count, bool lastByte = false);
 
    virtual bool write(uint16_t data, bool lastByte = false);
 
    virtual bool write16(uint16_t data, bool lastByte = false);
 
    virtual bool write32(uint32_t data, bool lastByte = false);
 
    virtual uint16_t receive(bool lastByte = false);
 
    virtual uint16_t receive16(bool lastByte = false);
 
    virtual uint32_t receive32(bool lastByte = false);
 
    virtual bool writeBytes(const uint8_t * data, uint32_t size, bool lastByte = false);
 
    virtual bool writeBytesNonBlocking(const uint8_t * data, uint32_t size, bool lastByte = false);
 
    virtual bool transferBytes(const uint8_t * out, uint8_t * in, uint32_t size, bool lastByte = false);
 
    virtual bool transferBytesNonBlocking(const uint8_t * out, uint8_t * in, uint32_t size, bool lastByte = false);
 
    virtual bool receiveBytes(uint8_t * data, uint32_t size, bool lastByte = false);
 
    virtual bool receiveBytesNonBlocking(uint8_t * data, uint32_t size, bool lastByte = false);
 //End of SPITransactionMethods
 
    virtual SPI_Status endTransaction(void);
 //End of SPITransactionInitMethods
 
 
    bool isFullDuplex();
 
    bool isRxEnabled();
 
    bool isTxEnabled();
 
    operator bool() const
    {
        return (&_hspi != NULL) && (IS_SPI_ALL_INSTANCE(_hspi->Instance));
    }
 
    inline bool available(){
        return __HAL_SPI_GET_FLAG(_hspi, SPI_FLAG_RXNE);
    }
 
    inline bool hasError(void)
    {
        return _hspi->ErrorCode != HAL_SPI_ERROR_NONE;
    }
 
    inline SPI_ErrorCode getError(void){
        return (SPI_ErrorCode)_hspi->ErrorCode;
    }
 
    inline void clearError(uint32_t clearMask = 0xFFFFFFFFUL){
        _hspi->ErrorCode = (_hspi->ErrorCode & (~clearMask));
    }
 
    virtual inline SPI_Status lastTransactionStatus(){
        return transactionError;
    }
 //End of SPIStateMethods
 
    inline void setWriteDoneCallback(void (* WriteDoneCallback_)() ){ WriteDoneCallback = WriteDoneCallback_; }
 
    inline void setTransferDoneCallback(void (* TransferDoneCallback_)() ){ TransferDoneCallback = TransferDoneCallback_; }
 
    inline void setReceiveDoneCallback(void (* ReceiveDoneCallback_)() ){ ReceiveDoneCallback = ReceiveDoneCallback_; }
 
    inline void setWriteHalfCallback(void (* WriteHalfCallback_)() ){ WriteHalfCallback = WriteHalfCallback_; }
 
    inline void setTransferHalfCallback(void (* TransferHalfCallback_)() ){ TransferHalfCallback = TransferHalfCallback_; }
 
    inline void setReceiveHalfCallback(void (* ReceiveHalfCallback_)() ){ ReceiveHalfCallback = ReceiveHalfCallback_; }
 
    inline void setErrorCallback(void (* ErrorCallback_)(SPI_ErrorCode) ){ ErrorCallback = ErrorCallback_; }
 
    static inline void handleWriteDoneCallback(SPI_TypeDef* instance);
 
    static inline void handleTransferDoneCallback(SPI_TypeDef* instance);
 
    static inline void handleReceiveDoneCallback(SPI_TypeDef* instance);
 
    static inline void handleWriteHalfCallback(SPI_TypeDef* instance);
 
    static inline void handleTransferHalfCallback(SPI_TypeDef* instance);
 
    static inline void handleReceiveHalfCallback(SPI_TypeDef* instance);
 
    static inline void handleErrorCallback(SPI_TypeDef* instance);
 //End of SPICallbackMethods
 
    static uint32_t getSPIIndex(SPI_TypeDef* instance);
 
    static HardwareSPI** getSPIInstances(); //returns pointer to instances
 
    static uint8_t getAvailableSPIsCount();
 
    SPI_HandleTypeDef& getHAL_SPI_Struct(){
        return *_hspi;
    }
 //End of SPIAdvancedMethods
 
protected:
    SPI_HandleTypeDef *_hspi = NULL;
 
    uint32_t _startMillis = 0;
 
    uint32_t timeout = 1000;
 
    SPISettings oldSettings;
 
    void (* WriteDoneCallback)() = NULL;
    void (* TransferDoneCallback)() = NULL;
    void (* ReceiveDoneCallback)() = NULL;
    void (* WriteHalfCallback)() = NULL;
    void (* TransferHalfCallback)() = NULL;
    void (* ReceiveHalfCallback)() = NULL;
    void (* ErrorCallback)(SPI_ErrorCode) = NULL;
 
    SPI_Status transactionError = SPI_OK;
 
    void inline clearCRCErrorFlag(){
        __HAL_SPI_CLEAR_CRCERRFLAG(_hspi);
    }
 
    void inline clearOVRErrorFlag(){
        __HAL_SPI_CLEAR_OVRFLAG(_hspi);
    }
 
    void inline clearMODFlag(){
        __HAL_SPI_CLEAR_MODFFLAG(_hspi);
    }
 
    void inline clearFREFlag(){
#ifdef __HAL_SPI_CLEAR_FREFLAG
        __HAL_SPI_CLEAR_FREFLAG(_hspi);
#endif
    }
 
    void addThisToInstArr();
 
    void removeThisFromInstArr();
 
    static HardwareSPI* instances[]; //There are stored pointers to all created instances of this class
 
    static uint8_t availableSPIsCount;
};
 
 
#if defined(STM32L432xx) || defined(DOXYGEN_FORCED)
 
 
class HardwareSPI_O: public HardwareSPI{
public:
    HardwareSPI_O(SPI_HandleTypeDef &hspi):HardwareSPI(hspi){
    }
 
    SPI_Status beginTransaction(SPISettings settings) override;
 //End of SPIOTransactionInitMethods
 
    uint16_t transfer(uint16_t data, bool lastByte = false) override;
 
    uint16_t transfer16(uint16_t data, bool lastByte = false) override;
 
    uint32_t transfer32(uint32_t data, bool lastByte = false) override;
 
    bool write(uint16_t data, bool lastByte = false) override;
 
    bool write16(uint16_t data, bool lastByte = false) override;
 
    bool write32(uint32_t data, bool lastByte = false) override;
 
    uint16_t receive(bool lastByte = false) override;
 
    uint16_t receive16(bool lastByte = false) override;
 
    uint32_t receive32(bool lastByte = false) override;
 
    bool transferBytes(const uint8_t * out, uint8_t * in, uint32_t size, bool lastByte = false) override;
 
    bool writeBytes(const uint8_t * data, uint32_t size, bool lastByte = false) override;
 
    bool receiveBytes(uint8_t * data, uint32_t size, bool lastByte = false) override;
 
    bool transfer(void *buf, uint16_t count, bool lastByte = false) override;
 //End of SPIOTransactionMethods
 
 
    SPI_Status endTransaction() override;
 //End of SPIOTransactionInitMethods
 
 
private:
    bool transactionEnabled = false;
 
    bool receiveEnabled = false;
 
    bool transmitEnabled = false;
 
    bool receiveUsed = false;
 
    bool transmitUsed = false;
 
#if (USE_SPI_CRC != 0U)
    bool SPI_isMasterAndNSSIsEnabled = false;
#endif /* USE_SPI_CRC */
 
    HAL_StatusTypeDef SPI_EndRxTxTransaction(uint32_t Timeout, uint32_t Tickstart);
    HAL_StatusTypeDef SPI_EndRxTransaction(uint32_t Timeout, uint32_t Tickstart);
    HAL_StatusTypeDef SPI_WaitFifoStateUntilTimeout(uint32_t Fifo, uint32_t State, uint32_t Timeout, uint32_t Tickstart);
    HAL_StatusTypeDef SPI_WaitFlagStateUntilTimeout(uint32_t Flag, FlagStatus State, uint32_t Timeout, uint32_t Tickstart);
};
 
#endif // defined(STM32L432xx) || defined(DOXYGEN_FORCED)
 
#endif //defined(HAL_SPI_MODULE_ENABLED) || defined(DOXYGEN_FORCED)
#endif //_SPI_H_INCLUDED