begin()

fl::optional< fl::task::Error > fl::spi::ParallelDevice::begin

(

)

Initialize hardware and setup LUT.

Returns

Optional error (nullopt on success)

Note

Auto-selects backend based on pin count and mode

Definition at line 154 of file parallel_device.cpp.hpp.

                                                           {
    if (!pImpl) {
        return fl::task::Error("Device not initialized");
    }
 
    if (pImpl->initialized) {
        // Already initialized - idempotent
        return fl::nullopt;
    }
 
    size_t num_pins = pImpl->config.gpio_pins.size();
 
    // Validate pin count
    if (num_pins == 0 || num_pins > 32) {
        return fl::task::Error("Invalid number of GPIO pins (must be 1-32)");
    }
 
    // Determine backend width (round up to next supported width: 1,2,4,8,16,32)
    u8 backend_width = 1;
    if (num_pins > 16) backend_width = 32;
    else if (num_pins > 8) backend_width = 16;
    else if (num_pins > 4) backend_width = 8;
    else if (num_pins > 2) backend_width = 4;
    else if (num_pins > 1) backend_width = 2;
 
    pImpl->backend_width = backend_width;
 
    // Determine execution mode
    bool use_isr = (pImpl->config.mode == SpiParallelMode::ISR_ASYNC) ||
                   (pImpl->config.mode == SpiParallelMode::AUTO);  // Default to ISR if AUTO
    pImpl->is_isr_mode = use_isr;
 
    // Build default LUT
    u32 set_masks[256];
    u32 clear_masks[256];
    buildDefaultLUT(pImpl->config.gpio_pins, set_masks, clear_masks);
 
    // Create and initialize backend
    // Note: We can't use polymorphism here due to different backend types
    // Instead, we use type-erasure with void* and manual dispatch
 
    if (use_isr) {
        // ISR-based backend
        FL_DBG("ParallelDevice: Initializing ISR mode (width=" << ((int)backend_width) << ")");
 
        // Note: These need to be heap-allocated for type-erasure
        // For now, return error indicating ISR mode not yet implemented
        return fl::task::Error("ISR mode not yet implemented for ParallelDevice");
 
    } else {
        // Bit-bang (blocking) backend
        FL_DBG("ParallelDevice: Initializing bit-bang mode (width=" << ((int)backend_width) << ")");
 
        // Note: These need to be heap-allocated for type-erasure
        // For now, return error indicating bit-bang mode not yet implemented
        return fl::task::Error("Bit-bang mode not yet implemented for ParallelDevice");
    }
 
    pImpl->initialized = true;
    return fl::nullopt;
}

References fl::AUTO, FL_DBG, fl::FL_NO_EXCEPT, fl::ISR_ASYNC, fl::nullopt, and pImpl.

Referenced by operator=().

Here is the caller graph for this function: