transmitBatch()

bool fl::SpiChannelEngineAdapter::transmitBatch ( fl::span< const ChannelDataPtr > channels )

private

Transmit a batch of channels (all same clock pin)

Parameters

channels

Channels to transmit (must have same clock pin)

Returns

true on success, false on error

Definition at line 340 of file spi_channel_adapter.cpp.hpp.

                                                                                 {
    if (channels.empty()) {
        return true;
    }
 
    // Extract clock pin and data pin from first channel (all same in batch)
    const auto& chipset = channels[0]->getChipset();
    if (!chipset.is<SpiChipsetConfig>()) {
        FL_WARN("SpiChannelEngineAdapter: Non-SPI chipset in transmitBatch");
        return false;
    }
 
    const SpiChipsetConfig& spiConfig = chipset.get<SpiChipsetConfig>();
    int clockPin = spiConfig.clockPin;
    int dataPin = channels[0]->getPin();  // MOSI pin from channel config
 
    // Select controller for this clock pin
    int controllerIndex = selectControllerForClockPin(clockPin);
    if (controllerIndex < 0) {
        FL_WARN("SpiChannelEngineAdapter: No available controller for clock pin " << clockPin);
        return false;
    }
 
    ControllerInfo& ctrl = mControllers[controllerIndex];
 
    // Initialize controller if needed
    if (!initializeControllerIfNeeded(ctrl, clockPin, dataPin)) {
        return false;
    }
 
    // Transmit using selected controller
    for (const auto& channel : channels) {
        if (!channel) {
            continue;
        }
 
        // Mark channel as in use
        channel->setInUse(true);
 
        // Get encoded data
        const auto& data = channel->getData();
        if (data.empty()) {
            FL_WARN("SpiChannelEngineAdapter: Empty channel data");
            channel->setInUse(false);
            continue;
        }
 
        FL_DBG("SpiChannelEngineAdapter: Transmitting channel via " << ctrl.name
               << " (pin " << channel->getPin() << ", " << data.size() << " bytes)");
 
        // Acquire DMA buffer
        DMABuffer dmaBuffer = ctrl.controller->acquireDMABuffer(data.size());
        if (!dmaBuffer.ok()) {
            FL_WARN("SpiChannelEngineAdapter: Failed to acquire DMA buffer (error "
                   << static_cast<int>(dmaBuffer.error()) << ")");
            channel->setInUse(false);
            return false;
        }
 
        // Copy data to DMA buffer
        fl::span<u8> buffer = dmaBuffer.data();
        if (buffer.size() < data.size()) {
            FL_WARN("SpiChannelEngineAdapter: DMA buffer too small ("
                   << buffer.size() << " < " << data.size() << ")");
            channel->setInUse(false);
            return false;
        }
 
        fl::memcpy(buffer.data(), data.data(), data.size());
 
        // Transmit (async mode for non-blocking operation)
        if (!ctrl.controller->transmit(TransmitMode::ASYNC)) {
            FL_WARN("SpiChannelEngineAdapter: Transmission failed");
            channel->setInUse(false);
            return false;
        }
 
        FL_DBG("SpiChannelEngineAdapter: Transmission queued successfully");
    }
 
    // Wait for transmission to complete (synchronous for now)
    // TODO: Make fully async by returning BUSY state and polling in poll()
    if (!ctrl.controller->waitComplete(1000)) {  // 1 second timeout
        FL_WARN("SpiChannelEngineAdapter: Transmission timeout");
        return false;
    }
 
    FL_DBG("SpiChannelEngineAdapter: Batch transmission complete");
    return true;
}

References fl::SpiChipsetConfig::clockPin, fl::SpiChannelEngineAdapter::ControllerInfo::controller, fl::span< T, Extent >::data(), FL_DBG, FL_WARN, initializeControllerIfNeeded(), mControllers, fl::memcpy(), fl::SpiChannelEngineAdapter::ControllerInfo::name, selectControllerForClockPin(), fl::basic_string::size(), and fl::span< T, Extent >::size().

Referenced by show().

Here is the call graph for this function:

Here is the caller graph for this function: