begin()

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

(

)

Initialize the SPI hardware.

Returns

Result indicating success or error

Note

Must be called before any communication methods

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

                                      {
    if (!pImpl) {
        return fl::task::Error("Device not initialized");
    }
 
    if (pImpl->initialized) {
        // Already initialized - idempotent
        return fl::nullopt;
    }
 
    // Validate SPI mode (0-3 for CPOL/CPHA combinations)
    if (pImpl->config.spi_mode > 3) {
        FL_WARN("SPI Device: Invalid SPI mode " << pImpl->config.spi_mode << " (must be 0-3)");
        return fl::task::Error("Invalid SPI mode");
    }
 
    // Note: SPI mode configuration is not yet supported by the hardware layer
    // All devices currently operate in mode 0 (CPOL=0, CPHA=0)
    if (pImpl->config.spi_mode != 0) {
        FL_WARN("SPI Device: SPI mode " << pImpl->config.spi_mode
                << " requested but hardware layer only supports mode 0 - ignoring");
    }
 
    // Register with SPIBusManager
    SPIBusManager& mgr = getSPIBusManager();
    int data_pin = pImpl->config.data_pins.empty() ? -1 : pImpl->config.data_pins[0];
    pImpl->bus_handle = mgr.registerDevice(
        pImpl->config.clock_pin,
        data_pin,
        pImpl->config.clock_speed_hz,
        this  // controller pointer
    );
 
    if (!pImpl->bus_handle.is_valid) {
        FL_WARN("SPI Device: Failed to register with bus manager");
        return fl::task::Error("Failed to register with bus manager");
    }
 
    // Initialize the bus
    if (!mgr.initialize()) {
        FL_WARN("SPI Device: Bus initialization failed");
        return fl::task::Error("Bus initialization failed");
    }
 
    // Check if we need to create our own SpiHw1 controller (SINGLE_SPI/passthrough mode)
    const SPIBusInfo* bus_info = mgr.getBusInfo(pImpl->bus_handle.bus_id);
    if (bus_info && bus_info->bus_type == SPIBusType::SINGLE_SPI && !bus_info->hw_controller) {
        // Create and initialize a SpiHw1 controller
        const fl::vector<fl::shared_ptr<SpiHw1>>& controllers = SpiHw1::getAll();
        if (controllers.empty()) {
            FL_WARN("SPI Device: No SpiHw1 controllers available on this platform");
            return fl::task::Error("No SpiHw1 controllers available");
        }
 
        // Use the first available controller (could be improved with bus number selection)
        fl::shared_ptr<SpiHw1> hw = controllers[0];
 
        SpiHw1::Config hw_config;
        hw_config.clock_pin = pImpl->config.clock_pin;
        hw_config.data_pin = pImpl->config.data_pins.empty() ? -1 : pImpl->config.data_pins[0];
        hw_config.clock_speed_hz = pImpl->config.clock_speed_hz;
        hw_config.bus_num = 0;  // Default to bus 0
 
        if (!hw->begin(hw_config)) {
            FL_WARN("SPI Device: Failed to initialize SpiHw1 controller");
            return fl::task::Error("Failed to initialize SpiHw1");
        }
 
        pImpl->hw_backend = hw;
        pImpl->owns_backend = false;  // We don't own it (it's from the static pool)
        FL_LOG_SPI("SPI Device: Created SpiHw1 controller for SINGLE_SPI mode");
    } else {
        // Multi-lane or hardware controller already exists
        pImpl->hw_backend = bus_info ? bus_info->hw_controller : nullptr;
        pImpl->owns_backend = false;
    }
 
    pImpl->initialized = true;
    FL_LOG_SPI("SPI Device: Initialized successfully");
    return fl::nullopt;
}

References fl::vector_basic::empty(), FL_LOG_SPI, FL_WARN, fl::nullopt, and pImpl.

Here is the call graph for this function: