adapter_spi.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_COMPONENT_ADAPTER_SPI_HPP
#define M5_UNIT_COMPONENT_ADAPTER_SPI_HPP
 
#include "adapter_base.hpp"
#if defined(ARDUINO)
#include <SPI.h>
#else
class SPIClass;
#endif
#if defined(ESP_PLATFORM)
#include <driver/spi_master.h>
#endif
 
// SPI is an ESP platform feature here (SPIImpl holds a gpio_num_t chip select)
#if defined(ESP_PLATFORM)
namespace m5 {
namespace unit {
 
class AdapterSPI : public Adapter {
public:
    class SPIImpl : public Adapter::Impl {
    public:
        explicit SPIImpl(const gpio_num_t cs = GPIO_NUM_NC) : _cs{cs}
        {
        }
        virtual ~SPIImpl() = default;
 
        inline virtual SPIClass* getSPI()
        {
            return nullptr;
        }
        inline gpio_num_t cs_pin() const
        {
            return _cs;
        }
 
        virtual void beginTransaction()
        {
        }
        virtual void endTransaction()
        {
        }
 
    protected:
        gpio_num_t _cs{GPIO_NUM_NC};
    };
 
#if defined(ARDUINO)
    class SPIClassImpl : public SPIImpl {
    public:
        SPIClassImpl(SPIClass& serial, const SPISettings& settings, const gpio_num_t cs);
        inline virtual SPIClass* getSPI() override
        {
            return _spi;
        }
        virtual void beginTransaction() override;
        virtual void endTransaction() override;
        virtual m5::hal::error::error_t readWithTransaction(uint8_t* data, const size_t len) override;
        virtual m5::hal::error::error_t writeWithTransaction(const uint8_t* data, const size_t len,
                                                             const uint32_t stop) override;
        virtual m5::hal::error::error_t writeWithTransaction(const uint8_t reg, const uint8_t* data, const size_t len,
                                                             const uint32_t stop) override;
        virtual m5::hal::error::error_t writeWithTransaction(const uint16_t reg, const uint8_t* data, const size_t len,
                                                             const uint32_t stop) override;
 
    protected:
        SPIClass* _spi{};
        SPISettings _settings{};
        static uint32_t transaction_count;
    };
#endif
 
#if defined(ESP_PLATFORM)
    class ESPIDFImpl : public SPIImpl {
    public:
        ESPIDFImpl(spi_device_handle_t handle, const gpio_num_t cs);
        virtual void beginTransaction() override;
        virtual void endTransaction() override;
        virtual m5::hal::error::error_t readWithTransaction(uint8_t* data, const size_t len) override;
        virtual m5::hal::error::error_t writeWithTransaction(const uint8_t* data, const size_t len,
                                                             const uint32_t stop) override;
        virtual m5::hal::error::error_t writeWithTransaction(const uint8_t reg, const uint8_t* data, const size_t len,
                                                             const uint32_t stop) override;
        virtual m5::hal::error::error_t writeWithTransaction(const uint16_t reg, const uint8_t* data, const size_t len,
                                                             const uint32_t stop) override;
 
    protected:
        m5::hal::error::error_t do_transmit(const uint8_t* tx, uint8_t* rx, const size_t len);
 
    private:
        spi_device_handle_t _handle{};
        gpio_num_t _cs{GPIO_NUM_NC};
        bool _in_transaction{false};
    };
#endif
 
#if defined(ARDUINO)
    AdapterSPI(SPIClass& spi, const SPISettings& settings, const gpio_num_t cs);
#endif
#if defined(ESP_PLATFORM)
    AdapterSPI(spi_device_handle_t handle, const gpio_num_t cs);
#endif
 
    inline SPIImpl* impl()
    {
        return static_cast<SPIImpl*>(_impl.get());
    }
    inline const SPIImpl* impl() const
    {
        return static_cast<SPIImpl*>(_impl.get());
    }
 
    inline gpio_num_t cs_pin() const
    {
        return impl()->cs_pin();
    }
 
    inline virtual void beginTransaction() override
    {
        impl()->beginTransaction();
    }
    inline virtual void endTransaction() override
    {
        impl()->endTransaction();
    }
 
protected:
    AdapterSPI() : Adapter(Adapter::Type::SPI, new SPIImpl())
    {
    }
 
protected:
    gpio_num_t _cs{GPIO_NUM_NC};
};
 
}  // namespace unit
}  // namespace m5
#endif  // ESP_PLATFORM
#endif