spiMultislave.h

Go to the documentation of this file.

#pragma once
#ifndef DSY_SPI_MULTISLAVE_H
#define DSY_SPI_MULTISLAVE_H
 
#include "daisy_core.h"
#include "spi.h"
#include "gpio.h"
 
namespace daisy
{
class MultiSlaveSpiHandle
{
  public:
    static constexpr size_t max_num_devices_ = 4;
    struct Config
    {
        struct
        {
            dsy_gpio_pin sclk; 
            dsy_gpio_pin miso; 
            dsy_gpio_pin mosi; 
            dsy_gpio_pin nss[max_num_devices_];
        } pin_config;
 
        SpiHandle::Config::Peripheral    periph;
        SpiHandle::Config::Direction     direction;
        unsigned long                    datasize;
        SpiHandle::Config::ClockPolarity clock_polarity;
        SpiHandle::Config::ClockPhase    clock_phase;
        SpiHandle::Config::BaudPrescaler baud_prescaler;
        size_t                           num_devices;
    };
 
    MultiSlaveSpiHandle() {}
    MultiSlaveSpiHandle(const MultiSlaveSpiHandle& other) = delete;
 
    SpiHandle::Result Init(const Config& config);
 
    const Config& GetConfig() const { return config_; }
 
    SpiHandle::Result BlockingTransmit(size_t   device_index,
                                       uint8_t* buff,
                                       size_t   size,
                                       uint32_t timeout = 100);
 
    SpiHandle::Result BlockingReceive(size_t   device_index,
                                      uint8_t* buff,
                                      uint16_t size,
                                      uint32_t timeout = 100);
 
    SpiHandle::Result BlockingTransmitAndReceive(size_t   device_index,
                                                 uint8_t* tx_buff,
                                                 uint8_t* rx_buff,
                                                 size_t   size,
                                                 uint32_t timeout = 100);
 
    SpiHandle::Result
    DmaTransmit(size_t                              device_index,
                uint8_t*                            buff,
                size_t                              size,
                SpiHandle::StartCallbackFunctionPtr start_callback,
                SpiHandle::EndCallbackFunctionPtr   end_callback,
                void*                               callback_context);
 
    SpiHandle::Result
    DmaReceive(size_t                              device_index,
               uint8_t*                            buff,
               size_t                              size,
               SpiHandle::StartCallbackFunctionPtr start_callback,
               SpiHandle::EndCallbackFunctionPtr   end_callback,
               void*                               callback_context);
 
    SpiHandle::Result
    DmaTransmitAndReceive(size_t                              device_index,
                          uint8_t*                            tx_buff,
                          uint8_t*                            rx_buff,
                          size_t                              size,
                          SpiHandle::StartCallbackFunctionPtr start_callback,
                          SpiHandle::EndCallbackFunctionPtr   end_callback,
                          void*                               callback_context);
 
    int CheckError();
 
  private:
    MultiSlaveSpiHandle& operator=(const MultiSlaveSpiHandle&)
    {
        return *this;
    };
 
    void        EnableDevice(size_t device_index);
    void        DisableDevice(size_t device_index);
    static void DmaStartCallback(void* context);
    static void DmaEndCallback(void* context, SpiHandle::Result result);
 
    Config    config_;
    SpiHandle spiHandle_;
    dsy_gpio  nss_pins[max_num_devices_];
 
    struct DmaTransfer
    {
        int8_t                              device_index;
        SpiHandle::StartCallbackFunctionPtr start_callback;
        SpiHandle::EndCallbackFunctionPtr   end_callback;
        void*                               callback_context;
 
        void Invalidate() { device_index = -1; }
        bool IsValid() const { return device_index >= 0; }
    } current_dma_transfer_;
};
 
} // namespace daisy
 
#endif // ifndef DSY_SPI_MULTISLAVE_H