validateParlioStreaming()

ValidateResult autoresearch::parlio_stream::validateParlioStreaming ( int base_tx_pin, int num_lanes, int num_leds, int iterations, uint32_t timeout_ms, const int * tx_pins = nullptr )

inline

Run the PARLIO streaming functional test.

Parameters

base_tx_pin	First PARLIO TX pin; lanes occupy [base_tx_pin .. base_tx_pin+num_lanes-1]
num_lanes	Number of PARLIO lanes (1-16). Use 16 to exercise BF1+pipe4.
num_leds	LEDs per lane.
iterations	Number of back-to-back show()+wait() cycles (capped at kMaxIterations).
timeout_ms	Per-iteration timeout. Test fails if any iter exceeds this.
tx_pins	Optional explicit per-lane pins. If null, uses contiguous base_tx_pin+lane.

Definition at line 104 of file AutoResearchParlioStream.h.

                                                                            {
    ValidateResult r{};
    r.channels_ok = false;
    r.completed = false;
    r.explicit_tx_pins = tx_pins != nullptr;
    r.base_tx_pin = base_tx_pin;
    r.lanes = num_lanes;
    r.leds_per_lane = num_leds;
    r.iterations = iterations;
    r.timeout_ms = timeout_ms;
    r.failed_iter = -1;
    for (int lane = 0; lane < kMaxLanes; ++lane) {
        r.tx_pins[lane] = -1;
    }
 
    if (iterations < 1) iterations = 1;
    if (iterations > kMaxIterations) iterations = kMaxIterations;
    r.iterations = iterations;
    if (!tx_pins && base_tx_pin < 0) return r;
    if (num_lanes < 1 || num_lanes > 16) return r;
    if (num_leds < 1) return r;
    if (tx_pins) {
        base_tx_pin = tx_pins[0];
        r.base_tx_pin = base_tx_pin;
        for (int lane = 0; lane < num_lanes; ++lane) {
            if (tx_pins[lane] < 0) return r;
        }
    }
 
#if defined(ARDUINO_ARCH_ESP32) || defined(ESP_PLATFORM)
    // Reuse a single static heap-resident LED buffer sized for the canonical
    // worst case (16 lanes × 256 LEDs). Test callers must stay within these
    // bounds. Static to avoid repeated allocation across RPC calls.
    if (num_leds > kMaxLeds) return r;
    CRGB (*leds)[kMaxLeds] = parlioLedState().leds;
    for (int lane = 0; lane < num_lanes; ++lane) {
        for (int i = 0; i < num_leds; ++i) {
            leds[lane][i] = CRGB(0xF0, 0x0F, 0xAA);  // Pattern A (mixed bits)
        }
    }
 
    fl::ChipsetTimingConfig timing =
        fl::makeTimingConfig<fl::TIMING_WS2812B_V5>();
 
    fl::ChannelOptions parlio_opts;
    parlio_opts.mBus = fl::Bus::FLEX_IO;
    parlio_opts.mBusWhich = 0;
 
    FastLED.clear(ClearFlags::CHANNELS);
 
    fl::vector<fl::shared_ptr<fl::Channel>> channels;
    for (int lane = 0; lane < num_lanes; ++lane) {
        const int tx_pin = tx_pins ? tx_pins[lane] : (base_tx_pin + lane);
        r.tx_pins[lane] = tx_pin;
        if (!isFastLedOutputPinValid(tx_pin)) {
            FastLED.clear(ClearFlags::CHANNELS);
            return r;
        }
        fl::ChannelConfig cfg(
            tx_pin,
            timing,
            fl::span<CRGB>(leds[lane], num_leds),
            RGB,
            parlio_opts);
        auto ch = FastLED.add(cfg);
        if (!ch) {
            FastLED.clear(ClearFlags::CHANNELS);
            return r;
        }
        channels.push_back(ch);
    }
    r.channels_ok = true;
 
    bool ok = true;
    uint32_t steady_total = 0;
    uint32_t steady_show_total = 0;
    uint32_t steady_wait_total = 0;
    for (int iter = 0; iter < iterations; ++iter) {
        const uint32_t t0 = micros();
        FastLED.show();
        const uint32_t t_show = micros();
        FastLED.wait(timeout_ms);
        const uint32_t t1 = micros();
        const uint32_t show_us = t_show - t0;
        const uint32_t wait_us = t1 - t_show;
        const uint32_t dt = t1 - t0;
        r.per_iter_us[iter] = dt;
        r.per_iter_show_us[iter] = show_us;
        r.per_iter_wait_us[iter] = wait_us;
        if (dt > timeout_ms * 1000u) {
            r.failed_iter = iter;
            ok = false;
            break;
        }
        if (iter > 0) {
            steady_total += dt;
            steady_show_total += show_us;
            steady_wait_total += wait_us;
        }
    }
 
    FastLED.clear(ClearFlags::CHANNELS);
 
#if defined(ESP32) && FASTLED_ESP32_HAS_PARLIO
    {
        auto metrics = fl::detail::ParlioEngine::getInstance().getDebugMetrics();
        r.tx_done_count = metrics.mTxDoneCount;
        r.worker_isr_count = metrics.mWorkerIsrCount;
        r.underrun_count = metrics.mUnderrunCount;
        r.ring_count = metrics.mRingCount;
        r.bytes_total = metrics.mBytesTotal;
        r.bytes_transmitted = metrics.mBytesTransmitted;
        r.ring_error = metrics.mRingError;
        r.hardware_idle = metrics.mHardwareIdle;
    }
#endif
 
    r.completed = ok;
    if (ok && iterations > 1) {
        r.steady_avg_us = steady_total / (iterations - 1);
        r.steady_avg_show_us = steady_show_total / (iterations - 1);
        r.steady_avg_wait_us = steady_wait_total / (iterations - 1);
    } else if (ok) {
        r.steady_avg_us = r.per_iter_us[0];
        r.steady_avg_show_us = r.per_iter_show_us[0];
        r.steady_avg_wait_us = r.per_iter_wait_us[0];
    }
#else
    (void)base_tx_pin;
    (void)timeout_ms;
#endif
    return r;
}

References CHANNELS, autoresearch::parlio_stream::ValidateResult::channels_ok, FastLED, fl::FLEX_IO, isFastLedOutputPinValid(), kMaxIterations, kMaxLanes, kMaxLeds, autoresearch::parlio_stream::ParlioLedState::leds, leds, fl::makeTimingConfig(), fl::ChannelOptions::mBus, fl::ChannelOptions::mBusWhich, parlioLedState(), fl::vector< T >::push_back(), and RGB.

Here is the call graph for this function: