autoResearchChipsetTiming()

void autoResearchChipsetTiming	(	fl::AutoResearchConfig &	config,
		int &	driver_total,
		int &	driver_passed,
		uint32_t &	out_show_duration_ms,
		fl::vector< fl::RunResult > *	out_results,
		int	num_runs_per_pattern )

Definition at line 1011 of file AutoResearchTest.cpp.

                                                     {
    fl::sstream ss;
    ss << "\n========================================\n";
    ss << "Testing: " << config.timing_name << "\n";
    bool has_spi_config = config.tx_configs.size() > 0 && config.tx_configs[0].isSpi();
    if (has_spi_config) {
        const auto* spi_cfg = config.tx_configs[0].getSpiChipset();
        ss << "  Protocol: SPI (APA102)\n";
        ss << "  Clock: " << (spi_cfg ? spi_cfg->timing.clock_hz : 0) << " Hz\n";
    } else {
        ss << "  T0H: " << config.timing.t1_ns << "ns\n";
        ss << "  T1H: " << (config.timing.t1_ns + config.timing.t2_ns) << "ns\n";
        ss << "  T0L: " << config.timing.t3_ns << "ns\n";
        ss << "  RESET: " << config.timing.reset_us << "us\n";
    }
    ss << "  Channels: " << config.tx_configs.size() << "\n";
    ss << "========================================";
    FL_WARN(ss.str());
 
    // Create ALL channels from tx_configs (multi-channel support)
    fl::vector<fl::shared_ptr<fl::Channel>> channels;
    for (size_t i = 0; i < config.tx_configs.size(); i++) {
        fl::shared_ptr<fl::Channel> channel;
        if (config.tx_configs[i].isSpi()) {
            // SPI chipset: pass through the SPI config directly
            channel = FastLED.add(config.tx_configs[i]);
        } else {
            // Clockless chipset: re-create with runtime timing
            fl::ChannelConfig channel_config(config.tx_configs[i].getDataPin(), config.timing, config.tx_configs[i].mLeds, config.tx_configs[i].rgb_order);
            channel = FastLED.add(channel_config);
        }
        if (!channel) {
            FL_ERROR("Failed to create channel " << i << " (pin " << config.tx_configs[i].getDataPin() << ") - platform not supported");
            // Clean up previously created channels
            for (auto& ch : channels) {
                ch.reset();
            }
            return;
        }
        channels.push_back(channel);
    }
 
    FastLED.setBrightness(255);
 
    // Pre-initialize the TX engine to avoid first-call setup delays
    for (size_t i = 0; i < config.tx_configs.size(); i++) {
        fill_solid(config.tx_configs[i].mLeds.data(), config.tx_configs[i].mLeds.size(), CRGB::Black);
    }
    FastLED.show();
    if (!FastLED.wait(1000)) {  // 1s timeout - driver stall guard
        FL_ERROR("[PREINIT] TX wait timeout - driver may be stalled on this platform");
        FastLED.clear(ClearFlags::CHANNELS);
        return;
    }
    // TX engine pre-init logging silenced for speed
 
    // CRITICAL: Wait for PARLIO streaming transmission to complete before starting tests
    // Without this delay, the RX will capture the pre-initialization BLACK frame instead of the test pattern
    // PARLIO is a streaming engine with ring buffers - need time to drain the initial frame
    delay(5);  // Reduced from 100ms - just enough for buffer drain
 
    // Run test patterns (mixed bit patterns to test MSB vs LSB handling)
    int total = 0;
    int passed = 0;
 
    // Multi-run configuration - optimized for speed
    fl::MultiRunConfig multi_config;
    // num_runs=1: Python orchestrates retries (default).
    // num_runs>=2: Back-to-back captures of the same buffer to expose second-frame
    // degradation (e.g., SPI driver zeroing its DMA buffer after the first show()).
    multi_config.num_runs = (num_runs_per_pattern > 0) ? num_runs_per_pattern : 1;
    multi_config.print_all_runs = (multi_config.num_runs > 1);
    multi_config.print_per_led_errors = false;  // Errors reported via JSON-RPC
    multi_config.max_errors_per_run = 10;  // Store first 10 errors for JSON response
 
    // Measure show-only duration (excludes setup/teardown overhead)
    uint32_t show_start_ms = millis();
 
    // Test all 4 bit patterns (0-3)
    for (int pattern_id = 0; pattern_id < 4; pattern_id++) {
        // Apply pattern to all lanes
        for (size_t i = 0; i < config.tx_configs.size(); i++) {
            setMixedBitPattern(
                config.tx_configs[i].mLeds.data(),
                config.tx_configs[i].mLeds.size(),
                pattern_id
            );
        }
        runMultiTest(getBitPatternName(pattern_id), config, multi_config, total, passed, out_results);
    }
 
    out_show_duration_ms += millis() - show_start_ms;
 
    // Results reported via JSON-RPC (verbose logging silenced for speed)
 
    // Accumulate results for driver-level tracking
    driver_total += total;
    driver_passed += passed;
 
    // Destroy ALL channels before testing next timing configuration
    // CRITICAL: Clear FastLED's global channel registry to prevent accumulation
    // If we only destroy local shared_ptrs, FastLED still holds references
    FastLED.clear(ClearFlags::CHANNELS);
    // Channel destruction is synchronous - no delay needed
}

References fl::CRGB::Black, CHANNELS, fl::span< T, Extent >::data(), FastLED, fill_solid(), FL_ERROR, FL_WARN, getBitPatternName(), fl::MultiRunConfig::max_errors_per_run, fl::MultiRunConfig::num_runs, fl::MultiRunConfig::print_all_runs, fl::MultiRunConfig::print_per_led_errors, fl::vector< T >::push_back(), fl::ChipsetTimingConfig::reset_us, runMultiTest(), setMixedBitPattern(), fl::span< T, Extent >::size(), fl::sstream::str(), fl::ChipsetTimingConfig::t1_ns, fl::ChipsetTimingConfig::t2_ns, fl::ChipsetTimingConfig::t3_ns, fl::AutoResearchConfig::timing, fl::AutoResearchConfig::timing_name, and fl::AutoResearchConfig::tx_configs.

Referenced by autoresearch::maybeRegisterStubAutorun(), AutoResearchRemoteControl::runParallelTestImpl(), AutoResearchRemoteControl::runSingleTestImpl(), and testDriver().

Here is the call graph for this function:

Here is the caller graph for this function: