fitUartWave()

UartWaveFit fl::anonymous_namespace{uart_wave_encoder.cpp.hpp}::fitUartWave	(	const ChipsetTimingConfig &	timing,
		u8	pulses_per_bit,
		u32	max_baud_rate )

Evaluate whether P pulses/LED-bit can represent the timing.

Shared by buildWave10Lut() and canRepresentTiming() so the LUT that gets built is always judged by the same rules that admitted it.

Definition at line 126 of file uart_wave_encoder.cpp.hpp.

                                                        {
    UartWaveFit fit = {};
    const u32 period_ns = timing.total_period_ns();
    if (period_ns == 0) return fit;
 
    // Baud = one UART bit per pulse = P / period. Must fit the ESP32
    // UART ceiling.
    const u64 baud =
        static_cast<u64>(pulses_per_bit) * 1000000000ULL / period_ns;
    if (baud == 0 || baud > max_baud_rate) return fit;
 
    const u32 pulse_width_ns = period_ns / pulses_per_bit;
    if (pulse_width_ns == 0) return fit;
 
    const u32 t0h_ns = timing.t1_ns;
    const u32 t1h_ns = timing.t1_ns + timing.t2_ns;
    const u8 max_pulses = static_cast<u8>(pulses_per_bit - 1);
 
    u8 pulses_0 = computePulseCount(t0h_ns, pulse_width_ns);
    u8 pulses_1 = computePulseCount(t1h_ns, pulse_width_ns);
    if (pulses_0 < 1 || pulses_0 > max_pulses) return fit;
    if (pulses_1 < 1 || pulses_1 > max_pulses) return fit;
    if (pulses_0 == pulses_1) return fit;
 
    // FastLED#3569/#3572 -- enforce a minimum ABSOLUTE wire separation
    // between the 0 and 1 symbols, widening T1H upward (a longer HIGH
    // still reads as 1). Best-fit rounding alone can land them one
    // pulse apart, and at high baud one pulse is too little: WS2812B-V5
    // at P=5 rounds to 245 vs 490 ns -- inside real WS281x parts'
    // sampling-threshold band (~550-625 ns); it flapped the WROOM bench
    // decoder. Slow chipsets (WS2811-400: 500+ ns pulses) already
    // exceed the floor with single-pulse separation.
    constexpr u32 kMinSymbolSeparationNs = 400;
    const u8 pulses_1_raw = pulses_1;
    while (pulses_1 < max_pulses &&
           static_cast<u32>(pulses_1 - pulses_0) * pulse_width_ns <
               kMinSymbolSeparationNs) {
        ++pulses_1;
    }
 
    // Quantized timing must be within half a pulse of nominal -- the
    // natural error bound for best-fit rounding. When the separation
    // bump deliberately widened T1H, allow exactly the pulses it added
    // on top of that bound.
    const u32 tolerance_ns = pulse_width_ns / 2;
    const u32 actual_t0h = static_cast<u32>(pulses_0) * pulse_width_ns;
    const u32 actual_t1h = static_cast<u32>(pulses_1) * pulse_width_ns;
    const u32 t1h_tolerance_ns =
        tolerance_ns +
        static_cast<u32>(pulses_1 - pulses_1_raw) * pulse_width_ns;
    const u32 err_t0h = absDiff(actual_t0h, t0h_ns);
    const u32 err_t1h = absDiff(actual_t1h, t1h_ns);
    if (err_t0h > tolerance_ns) return fit;
    if (err_t1h > t1h_tolerance_ns) return fit;
 
    const u32 raw_t1h = static_cast<u32>(pulses_1_raw) * pulse_width_ns;
    const u32 err_t1h_raw = absDiff(raw_t1h, t1h_ns);
 
    fit.ok = true;
    fit.pulses_0 = pulses_0;
    fit.pulses_1 = pulses_1;
    fit.total_err_ns = err_t0h + err_t1h;
    fit.max_err_ns = err_t0h > err_t1h_raw ? err_t0h : err_t1h_raw;
    return fit;
}

References absDiff(), computePulseCount(), fitUartWave(), fl::FL_NO_EXCEPT, fl::anonymous_namespace{uart_wave_encoder.cpp.hpp}::UartWaveFit::max_err_ns, fl::anonymous_namespace{uart_wave_encoder.cpp.hpp}::UartWaveFit::ok, fl::anonymous_namespace{uart_wave_encoder.cpp.hpp}::UartWaveFit::pulses_0, fl::anonymous_namespace{uart_wave_encoder.cpp.hpp}::UartWaveFit::pulses_1, and fl::anonymous_namespace{uart_wave_encoder.cpp.hpp}::UartWaveFit::total_err_ns.

Referenced by fitUartWave().

Here is the call graph for this function:

Here is the caller graph for this function: