run()

DriftResult autoresearch::timing_drift::run ( int pin, int num_leds, int iterations )

inline

Definition at line 87 of file AutoResearchTimingDrift.h.

                                                              {
    DriftResult r{};
    r.pin = pin;
 
    if (iterations < 1) iterations = 1;
    if (iterations > kMaxIterations) iterations = kMaxIterations;
    if (num_leds < 2) num_leds = 2;
    if (num_leds > kMaxLeds) num_leds = kMaxLeds;
    r.num_leds = num_leds;
 
    CRGB* leds = timingDriftState().leds;
    for (int i = 0; i < num_leds; ++i) {
        leds[i] = CRGB::Black;
    }
 
    // Probe whether the requested pin is dispatchable BEFORE mutating any
    // global state — invalid pins must not clear other RPC tests' channels.
    {
        LegacyClocklessProxy probe(pin, leds, num_leds);
        if (!probe.valid()) {
            return r;  // valid_pin stays false; no side effects
        }
    }
 
    // Clean slate: drop any channels left over from earlier RPC tests so
    // show() drives only the legacy controller under test.
    FastLED.clear(ClearFlags::CHANNELS);
 
    LegacyClocklessProxy proxy(pin, leds, num_leds);
    r.valid_pin = true;
 
#if defined(ARDUINO_ARCH_ESP32)
    r.cpu_mhz = getCpuFrequencyMhz();
#endif
 
    // sketch setup() — addLeds happened in the proxy above.
    FastLED.setMaxRefreshRate(800);
    FastLED.show();
 
    constexpr uint32_t kFastLedUpdateMs = 5;
    MillisDelay ms_fast_led;
    MillisDelay ms_delay_post;
 
    ms_delay_post.start(0);
    ms_fast_led.start(kFastLedUpdateMs);
 
    int i_post_fade = 255;
    uint32_t i_iteration_time = millis();
    int completed = 0;
 
    r.show_min_us = 0xFFFFFFFFu;
 
    auto timedShow = [&]() {
        const uint32_t t0 = micros();
        FastLED.show();
        const uint32_t dt = micros() - t0;
        r.show_count++;
        r.show_total_us += dt;
        if (dt < r.show_min_us) r.show_min_us = dt;
        if (dt > r.show_max_us) r.show_max_us = dt;
    };
 
    auto updateLEDs = [&]() {
        if (ms_fast_led.justFinished()) {
            timedShow();
            ms_fast_led.start(kFastLedUpdateMs);
        }
    };
 
    const int i_ring_start = 0;
    const int i_ring_end = num_leds - 1;
    const int i_ring_divisor = 7;
 
    // Each sequence runs ~2.5 s and we may queue up to kMaxIterations of
    // them, so feed the AutoResearch watchdog (5 s timeout) on a coarse
    // cadence to keep the device alive through long runs.
    uint32_t last_wdt_feed_ms = millis();
    constexpr uint32_t kWdtFeedIntervalMs = 1000;
    auto maybeFeedWatchdog = [&]() {
        const uint32_t now = millis();
        if (now - last_wdt_feed_ms >= kWdtFeedIntervalMs) {
            FastLED.watchdog().feed();
            last_wdt_feed_ms = now;
        }
    };
 
    // Transliteration of the sketch's loop(); `continue` stands in for the
    // sketch's early `return` (Arduino re-enters loop()).
    while (completed < iterations) {
        if (i_post_fade > 0 && ms_delay_post.justFinished()) {
            const int i_ring_counter =
                ((255 - i_post_fade) / i_ring_divisor) + i_ring_start;
 
            if (i_ring_counter <= i_ring_end) {
                leds[i_ring_counter] = CRGB::Red;
            }
            if (i_ring_counter - 1 >= i_ring_start &&
                i_ring_counter - 1 <= i_ring_end) {
                leds[i_ring_counter - 1] = CRGB::Black;
            }
 
            i_post_fade--;
 
            if (i_post_fade == 0) {
                const uint32_t now = millis();
                r.iter_ms[completed] = now - i_iteration_time;
                completed++;
                i_iteration_time = now;
                ms_delay_post.stop();
 
                for (int i = i_ring_start; i <= i_ring_end; i++) {
                    leds[i] = CRGB::Black;
                }
 
                updateLEDs();
                FastLED.watchdog().feed();  // before the 1 s sleep
                delay(1000);
                FastLED.watchdog().feed();  // after the 1 s sleep
                last_wdt_feed_ms = millis();
                i_post_fade = 255;
                ms_delay_post.start(225);
                continue;
            } else {
                ms_delay_post.start(5);
            }
        }
        updateLEDs();
        maybeFeedWatchdog();
    }
 
    r.iterations = completed;
    if (r.show_count == 0) {
        r.show_min_us = 0;
    }
 
    // Teardown: restore unthrottled refresh (boot default). The proxy
    // destructor removes the legacy controller from the draw list.
    FastLED.setMaxRefreshRate(0);
    return r;
}

References fl::CRGB::Black, CHANNELS, FastLED, autoresearch::timing_drift::MillisDelay::justFinished(), kMaxIterations, kMaxLeds, autoresearch::timing_drift::TimingDriftState::leds, leds, autoresearch::timing_drift::DriftResult::pin, fl::CRGB::Red, autoresearch::timing_drift::MillisDelay::start(), autoresearch::timing_drift::MillisDelay::stop(), timingDriftState(), updateLEDs(), and LegacyClocklessProxy::valid().

Here is the call graph for this function: