write()

template<typename... Spans>

WriteResult fl::spi::MultiLaneDevice::write ( Spans &&... lanes )

inline

Convenience method - write multiple lanes in parallel (variadic template)

Template Parameters

Spans

Variadic template parameter pack (all must be convertible to fl::span<const uint8_t>)

Parameters

lanes

Lane data as spans (can be 1-8 lanes)

Returns

WriteResult with ok=true on success, or ok=false with error message

Note

Automatically waits for previous transmission, then starts new one asynchronously

Call wait() to block until transmission completes

IMPORTANT: All lanes MUST have identical sizes. Operation fails if sizes differ.

Users must handle chipset-specific padding at application level before calling write()

fl::array<uint8_t, 16> lane0 = {...};
fl::array<uint8_t, 16> lane1 = {...};  // Same size as lane0!
fl::array<uint8_t, 16> lane2 = {...};  // Same size as lane0!
fl::array<uint8_t, 16> lane3 = {...};  // Same size as lane0!
 
// Async usage - transmission happens in background
auto result = spi->write(lane0, lane1, lane2, lane3);
if (!result.ok) {
    FL_WARN("Write failed: " << result.error);
}
// ... do other work ...
 
// Sync usage - wait for completion
spi->write(lane0, lane1, lane2, lane3);
spi->wait();  // Block until done

Definition at line 169 of file multi_lane_device.h.

                                        {
        // Unpack variadic template into stack-allocated FixedVector
        fl::span<const u8> lane_spans[] = {fl::forward<Spans>(lanes)...};
        fl::FixedVector<fl::span<const u8>, MAX_SPI_LANES> lane_vec;
 
        // Copy spans into vector
        for (size_t i = 0; i < sizeof...(lanes); i++) {
            lane_vec.push_back(lane_spans[i]);
        }
 
        // Single atomic write operation
        return writeImpl(lane_vec);
    }

References fl::fl::forward(), fl::MAX_SPI_LANES, fl::FixedVector< T, N >::push_back(), and writeImpl().

Here is the call graph for this function: