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
    );

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

    bool canHandle(const ChannelDataPtr& data) const override;

    void enqueue(ChannelDataPtr channelData) override;

    void show() override;

    DriverState poll() override;

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

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

    int getPriority() const;
 
private:
    template<typename T, typename... Args>
    friend fl::shared_ptr<T> fl::make_shared(Args&&... args) FL_NOEXCEPT;

    SpiChannelEngineAdapter(const char* name);

    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)
            : controller(ctrl), priority(prio), name(n), isInitialized(false) {}
    };
 
    struct ClockPinAssignment {
        int clockPin;
        size_t controllerIndex;  
    };

    int selectControllerForClockPin(int clockPin);

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

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

    struct ClockPinGroup {
        int clockPin;
        fl::vector<ChannelDataPtr> channels;
    };

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

    bool transmitBatch(fl::span<const ChannelDataPtr> channels);
 
    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_NOEXCEPT = delete;
    SpiChannelEngineAdapter& operator=(const SpiChannelEngineAdapter&) FL_NOEXCEPT = delete;
    SpiChannelEngineAdapter(SpiChannelEngineAdapter&&) FL_NOEXCEPT = delete;
    SpiChannelEngineAdapter& operator=(SpiChannelEngineAdapter&&) FL_NOEXCEPT = delete;
};
 
} // namespace fl