waitForCondition()

template<typename Condition>

bool fl::ChannelManager::waitForCondition ( Condition condition, u32 timeoutMs = 1000 )

private

Wait until a condition is met, with check-pump-delay logic.

Parameters

condition	Function that returns true when waiting should stop
timeoutMs	Optional timeout in milliseconds (0 = no timeout)

Returns

true if condition was met, false if timeout occurred

Note

Runs async_run() on each iteration and delays intelligently to avoid busy-waiting

Definition at line 450 of file manager.cpp.hpp.

                                                                        {
    const u32 startTime = timeoutMs > 0 ? millis() : 0;
 
    // Tier 1: instant non-blocking check (avoid micros() / millis() cost on
    // the common already-ready path).
    if (condition()) {
        return true;
    }
 
    // Tier 2: bounded microsecond spin (#2818). Catches short DMA tails
    // (APA102 small strips, WS2812B <=8 LEDs) without paying the >=1-tick
    // floor of the cooperator yield below. Budget is runtime-tunable via
    // FastLED.setWaitSpinBudgetUs(N); set to 0 to disable.
    {
        const u32 spinBudget = fl::detail::getWaitSpinBudgetUs();
        if (spinBudget > 0) {
            const u32 spinStart = fl::micros();
            while ((fl::micros() - spinStart) < spinBudget) {
                if (condition()) {
                    return true;
                }
                if (timeoutMs > 0 && (millis() - startTime) >= timeoutMs) {
                    FL_ERROR("ChannelManager: Timeout occurred while waiting for condition");
                    return false;
                }
            }
        }
    }
 
    while (!condition()) {
        // Check timeout if specified
        if (timeoutMs > 0 && (millis() - startTime >= timeoutMs)) {
            FL_ERROR("ChannelManager: Timeout occurred while waiting for condition");
            return false;  // Timeout occurred
        }
 
        const u32 sliceMs = pollNeededWaitSliceMs(startTime, timeoutMs);
        if (sliceMs == 0) {
            return false;
        }
        if (waitForPollNeededSignal(sliceMs)) {
            continue;
        }
 
        // Adaptive yield (refs #2815, generalizes the #2493 ESP32-P4 carve-out):
        //
        // The 1-tick (>=1 ms at CONFIG_FREERTOS_HZ=1000) floor only exists to
        // keep WiFi / lwIP / BT controller tasks alive while we are inside the
        // channel wait loop (#2254). When no radio is actually up, that floor
        // is pure timing drift -- visible as the regression reported in #2420
        // and as the per-frame cost the #2493 ESP32-P4 carve-out was avoiding.
        //
        // NetworkDetector::isAnyNetworkActive() is the runtime version of the
        // "is a radio up?" question. On non-ESP32 platforms and on ESP32-P4
        // (no radio silicon) it folds to a constant `false`, so this is
        // strictly a perf win for the common single-strip / no-WiFi case
        // without losing the WiFi-friendly behavior when a radio is active.
        if (fl::NetworkDetector::isAnyNetworkActive()) {
            // Radio active: keep WiFi/lwIP/BT alive with the deep yield.
            task::run(250, task::ExecFlags::SYSTEM);
        } else {
            // No radio: fast yield, no FreeRTOS tick floor.
            task::run(0, task::ExecFlags::SYSTEM);
        }
    }
 
    return true;  // Condition met
}

References FL_ERROR, fl::detail::getWaitSpinBudgetUs(), fl::net::NetworkDetector::isAnyNetworkActive(), fl::micros(), fl::millis(), pollNeededWaitSliceMs(), fl::task::run(), fl::task::SYSTEM, and waitForPollNeededSignal().

Referenced by waitForReady(), and waitForReadyOrDraining().

Here is the call graph for this function:

Here is the caller graph for this function: