writeAsync()

Result< Transaction > fl::spi::Device::writeAsync	(	const u8 *	data,
		size_t	size )

Begin asynchronous write operation (returns immediately)

Parameters

data	Data to transmit (caller must keep alive until transaction completes)
size	Number of bytes to transmit

Returns

Result containing Transaction handle or error

Note

This is the primary transmission interface

Warning

Caller must ensure data remains valid until Transaction::wait() returns

Example:

uint8_t data[] = {0x01, 0x02, 0x03};
auto result = spi.writeAsync(data, sizeof(data));
if (result.ok()) {
    result.value().wait();  // Wait for completion
}

Definition at line 184 of file device.cpp.hpp.

                                                                  {
    if (!isReady()) {
        return Result<Transaction>::failure(SPIError::NOT_INITIALIZED, "Device not initialized");
    }
 
    if (!data || size == 0) {
        return Result<Transaction>::failure(SPIError::ALLOCATION_FAILED, "Invalid data or size");
    }
 
    // Check if an async operation is already in progress
    if (pImpl->async_state.active) {
        return Result<Transaction>::failure(SPIError::BUSY, "Another async operation is in progress");
    }
 
    // Acquire DMA buffer
    DMABuffer buffer = acquireBuffer(size);
    if (!buffer.ok()) {
        FL_WARN("SPI Device: Failed to acquire DMA buffer for async write");
        return Result<Transaction>::failure(buffer.error(), "Failed to acquire DMA buffer");
    }
 
    // Copy data to DMA buffer
    fl::span<u8> buf_span = buffer.data();
    if (buf_span.size() < size) {
        FL_WARN("SPI Device: Buffer size mismatch");
        return Result<Transaction>::failure(SPIError::BUFFER_TOO_LARGE, "Buffer size mismatch");
    }
 
    for (size_t i = 0; i < size; i++) {
        buf_span[i] = data[i];
    }
 
    // Start async transmission
    fl::optional<fl::task::Error> tx_result = transmit(buffer, true);  // true = async
    if (tx_result) {  // If error is present
        FL_WARN("SPI Device: Failed to start async transmission");
        return Result<Transaction>::failure(SPIError::NOT_SUPPORTED, tx_result->message.c_str());
    }
 
    // Store async state
    pImpl->async_state.active = true;
    pImpl->async_state.tx_buffer = data;
    pImpl->async_state.rx_buffer = nullptr;
    pImpl->async_state.size = size;
    pImpl->async_state.start_time = fl::millis();
 
    // Create Transaction object with proper initialization
    Transaction txn;
    txn.pImpl = fl::make_unique<Transaction::Impl>(this);
    txn.pImpl->completed = false;  // Will complete when hardware finishes
 
    FL_LOG_SPI("SPI Device: Async write started (" << size << " bytes)");
    return Result<Transaction>::success(fl::move(txn));
}

References acquireBuffer(), fl::span< T, Extent >::data(), fl::expected< T, E >::failure(), FL_LOG_SPI, FL_WARN, isReady(), fl::make_unique(), fl::millis(), fl::fl::move(), pImpl, fl::spi::Transaction::pImpl, fl::span< T, Extent >::size(), fl::expected< T, E >::success(), Transaction, and transmit().

Here is the call graph for this function: