legacyAsyncProbe()

fl::json autoresearch::legacyAsyncProbe ( const fl::json & args )

inline

Call after the regular driver test has registered the selected backend.

Poll only at the two observation points; application work between them deliberately performs no delay, yield, wait, or driver servicing.

Definition at line 426 of file AutoResearchLegacyAsync.h.

                                                   {
    int pin = 4;
    int count = 2000;
    if (args.is_object()) {
        if (args["pin"].is_int()) { pin = static_cast<int>(args["pin"].as_int().value()); }
        if (args["numLeds"].is_int()) { count = static_cast<int>(args["numLeds"].as_int().value()); }
    }
    fl::json result = fl::json::object();
    if (count < 100 || count > 4096) {
        result.set("success", false);
        result.set("error", "numLeds must be in [100,4096]");
        return result;
    }
    const char* name = legacyClocklessBoundDriverName();
    auto driver = name ? fl::channelManager().findDriverByName(name) : nullptr;
    if (!driver) {
        result.set("success", false);
        result.set("error", "Run the regular driver test first to register the backend");
        return result;
    }
    FastLED.clear(ClearFlags::CHANNELS);
    FastLED.setBrightness(255);
    const fl::string scenario = args.is_object()
        ? args["scenario"].as_string().value_or("") : fl::string();
    const bool legacyOnly = scenario == "replacement" ||
        (args.is_object() && args["legacyOnly"].as_bool().value_or(false));
    if (scenario == "mixed" && legacyOnly) {
        result.set("success", false);
        result.set("error", "Mixed Channel API coverage requires the manager listener");
        return result;
    }
    LegacyAsyncManagerScope managerScope(legacyOnly);
#if AUTORESEARCH_LEGACY_OBSERVES_RMT4_FRAMES // ok platform specific - this fixture requires RMT4-only worker diagnostics or fault-test configuration, with no neutral equivalent.
    if (scenario == "standalone" || scenario == "enable" || scenario == "backpressure") {
        if (count < 1000) { count = 1000; }
        result = legacyAsyncControllerProbe(scenario, pin, count, driver);
        result.set("legacyOnly", legacyOnly);
        return result;
    }
    if (scenario == "replacement") {
        if (count < 1000) { count = 1000; }
        result = legacyAsyncReplacementProbe(pin, count, driver);
        result.set("legacyOnly", legacyOnly);
        return result;
    }
    if (scenario == "mixed") {
        if (count < 1000) { count = 1000; }
        return legacyAsyncMixedProbe(pin, count, driver);
    }
    if (args.is_object() && args["overflow"].is_bool() &&
        args["overflow"].as_bool().value()) {
        if (count < 1000) { count = 1000; }
        return legacyAsyncOverflowProbe(count, driver);
    }
#endif
    fl::vector<CRGB> leds;
    leds.resize(static_cast<size_t>(count));
    if (leds.size() != static_cast<size_t>(count)) { return legacyPixelAllocationFailure(); }
    fill_solid(leds.data(), count, CRGB::White);
    LegacyClocklessProxy proxy(pin, leds.data(), count);
    if (!proxy.valid()) {
        result.set("success", false);
        result.set("error", "Unsupported legacy pin");
        return result;
    }
    FastLED.setBrightness(255);
    const fl::u32 showStarted = fl::micros();
    FastLED.show();
    const fl::u32 showDurationUs = fl::micros() - showStarted;
    auto stateAtReturn = driver->poll().state;
    const bool returnedActive = stateAtReturn == fl::IChannelDriver::DriverState::BUSY ||
                                stateAtReturn == fl::IChannelDriver::DriverState::DRAINING;
    size_t encodedBytes = 0;
    int firstEncodedByte = -1;
#if AUTORESEARCH_LEGACY_OBSERVES_RMT4_FRAMES // ok platform specific - this fixture requires RMT4-only worker diagnostics or fault-test configuration, with no neutral equivalent.
    {
        auto frame = proxy.frameData().lock();
        if (frame) {
            encodedBytes = frame->getSize();
            if (encodedBytes) { firstEncodedByte = frame->getData()[0]; }
        }
    }
#endif
    // Mutating the caller's pixels must not mutate the encoded frame in flight.
    fill_solid(leds.data(), count, CRGB::Blue);
    unsigned highSamples = 0;
    const fl::u32 start = fl::micros();
    int firstHighDelayUs = -1;
    // Startup may be queued when show returns. Sample through the full drain
    // window without calling any driver service, wait, yield, or delay.
    while (fl::micros() - start < 200000) {
        const fl::u32 elapsed = fl::micros() - start;
        if (digitalRead(pin)) {
            ++highSamples;
            if (firstHighDelayUs < 0) { firstHighDelayUs = static_cast<int>(elapsed); }
        }
    }
    const auto stateAfterIdle = driver->poll().state;
    const bool completedIndependently = stateAfterIdle == fl::IChannelDriver::DriverState::READY;
    const bool drained = FastLED.wait(1000);
    result.set("returnedActive", returnedActive);
    result.set("stateAtReturn", static_cast<int>(stateAtReturn));
    result.set("showDurationUs", static_cast<int>(showDurationUs));
    result.set("encodedBytes", static_cast<int>(encodedBytes));
    result.set("firstEncodedByte", firstEncodedByte);
    result.set("firstHighDelayUs", firstHighDelayUs);
    result.set("padHighSamplesAfterReturn", static_cast<int>(highSamples));
    result.set("completedWithoutApplicationPolling", completedIndependently);
    result.set("waitSucceeded", drained);
#if AUTORESEARCH_LEGACY_OBSERVES_RMT4_FRAMES // ok platform specific - this fixture requires RMT4-only worker diagnostics or fault-test configuration, with no neutral equivalent.
    addLegacyTxDiagnostics(result);
#endif
#if AUTORESEARCH_LEGACY_OBSERVES_RMT4_FRAMES && FL_RMT4_ASYNC // ok platform specific - measure the RMT4 worker's stack without adding a cross-platform virtual API.
    auto& selected = static_cast<fl::Rmt4AsyncDriver&>(fl::BusTraits<fl::Bus::RMT>::instance()); // ok platform specific - observe the selected RMT4 worker internals without adding a generic driver diagnostic API.
    result.set("workerStackUnusedBytes", static_cast<int>(selected.workerStackHighWaterBytes())); // ok platform specific - observe the selected RMT4 worker internals without adding a generic driver diagnostic API.
#endif
    result.set("success", returnedActive && highSamples > 0 && completedIndependently && drained);
    return result;
}

References args, fl::CRGB::Blue, fl::IChannelDriver::DriverState::BUSY, fl::channelManager(), CHANNELS, fl::IChannelDriver::DriverState::DRAINING, FastLED, fill_solid(), fl::ChannelManager::findDriverByName(), leds, legacyClocklessBoundDriverName(), legacyPixelAllocationFailure(), fl::micros(), fl::json::object(), fl::IChannelDriver::DriverState::READY, LegacyClocklessProxy::valid(), and fl::CRGB::White.

Here is the call graph for this function: