spi_channel_adapter.h

Go to the documentation of this file.

 
#pragma once
 
#include "fl/stl/noexcept.h"
 
#include "fl/channels/driver.h"
#include "fl/channels/data.h"
#include "fl/stl/vector.h"
#include "fl/stl/shared_ptr.h"
#include "fl/stl/string.h"
// IWYU pragma: begin_keep
#include "platforms/shared/spi_hw_base.h"  // ok platform headers - required for SpiHwBase interface
// IWYU pragma: end_keep
 
namespace fl {

class SpiChannelEngineAdapter : public IChannelDriver {
public:
    static fl::shared_ptr<SpiChannelEngineAdapter> create(
        fl::vector<fl::shared_ptr<SpiHwBase>> hwControllers,
        fl::vector<int> priorities,
        fl::vector<const char*> names,
        const char* adapterName
    ) FL_NO_EXCEPT;

    ~SpiChannelEngineAdapter() FL_NO_EXCEPT override;
 
    // IChannelDriver interface implementation

    bool canHandle(const ChannelDataPtr& data) const FL_NO_EXCEPT override;

    void enqueue(ChannelDataPtr channelData) FL_NO_EXCEPT override;

    void show() FL_NO_EXCEPT override;

    DriverState poll() FL_NO_EXCEPT override;

    fl::string getName() const FL_NO_EXCEPT override { return mName; }

    Capabilities getCapabilities() const FL_NO_EXCEPT override {
        return Capabilities(false, true);  // SPI only
    }

    int getPriority() const FL_NO_EXCEPT;
 
private:
    template<typename T, typename... Args>
    friend fl::shared_ptr<T> fl::adl_barrier::make_shared(Args&&... args) FL_NO_EXCEPT;  // see fl/stl/adl_barrier.h

    SpiChannelEngineAdapter(const char* name) FL_NO_EXCEPT;

    struct ControllerInfo {
        fl::shared_ptr<SpiHwBase> controller;  
        int priority;                          
        fl::string name;                       
        fl::vector<int> assignedClockPins;     
        bool isInitialized;                    
 
        ControllerInfo(fl::shared_ptr<SpiHwBase> ctrl, int prio, const char* n)
            FL_NO_EXCEPT : controller(ctrl), priority(prio), name(n), isInitialized(false) {}
    };
 
    struct ClockPinAssignment {
        int clockPin;
        Esp32SpiBus requestedBus;
        size_t controllerIndex;  
    };

    int selectControllerForClockPin(int clockPin, Esp32SpiBus requestedBus) FL_NO_EXCEPT;

    bool canControllerHandleClockPin(const ControllerInfo& ctrl, int clockPin) const FL_NO_EXCEPT;

    bool initializeControllerIfNeeded(ControllerInfo& ctrl, int clockPin, int dataPin) FL_NO_EXCEPT;

    struct ClockPinGroup {
        int clockPin;
        Esp32SpiBus requestedBus = Esp32SpiBus::AUTO;
        fl::vector<ChannelDataPtr> channels;
    };

    fl::vector<ClockPinGroup> groupByClockPin(
        fl::span<const ChannelDataPtr> channels
    ) FL_NO_EXCEPT;

    bool transmitBatch(fl::span<const ChannelDataPtr> channels) FL_NO_EXCEPT;
 
    fl::vector<ControllerInfo> mControllers;              
    fl::vector<ClockPinAssignment> mClockPinAssignments;  
    fl::string mName;                                    
 
    fl::vector<ChannelDataPtr> mEnqueuedChannels;      
    fl::vector<ChannelDataPtr> mTransmittingChannels;  
 
    // Non-copyable, non-movable
    SpiChannelEngineAdapter(const SpiChannelEngineAdapter&) FL_NO_EXCEPT = delete;
    SpiChannelEngineAdapter& operator=(const SpiChannelEngineAdapter&) FL_NO_EXCEPT = delete;
    SpiChannelEngineAdapter(SpiChannelEngineAdapter&&) FL_NO_EXCEPT = delete;
    SpiChannelEngineAdapter& operator=(SpiChannelEngineAdapter&&) FL_NO_EXCEPT = delete;
};
 
} // namespace fl