decodeFlexPwmEdges()

fl::result< u32, DecodeError > fl::channels::rx::decodeFlexPwmEdges	(	const ChipsetTiming4Phase &	timing,
		fl::span< const EdgeTime >	edges,
		fl::span< u8 >	bytes_out )

Batch decoder over an edge list (HIGH, LOW, HIGH, ... with a LOW left out after a gap).

Used for injectEdges() and as the reference the streaming decoder must match.

Definition at line 16 of file ws2812_stream_decoder.cpp.hpp.

                                                      {
    if (edges.size() == 0 || bytes_out.size() == 0) {
        return fl::result<u32, DecodeError>::success(0);
    }
 
    // Pre-pass: the adaptive midpoint from the observed HIGH widths.
    u32 high_min = 0xFFFFFFFFu;
    u32 high_max = 0u;
    u32 high_samples = 0;
    for (size_t k = 0; k + 1 < edges.size(); k += 2) {
        if (!edges[k].high) continue;
        const u32 h = edges[k].ns;
        if (!flexPwmIsMidpointSample(h)) continue;
        if (h < high_min) high_min = h;
        if (h > high_max) high_max = h;
        ++high_samples;
    }
    const u32 midpoint =
        flexPwmAdaptiveMidpointNs(timing, high_min, high_max, high_samples);
 
    u32 byte_index = 0;
    u8 current_byte = 0;
    u32 bit_count = 0;
    u32 error_count = 0;
    u32 total_bits = 0;
 
    size_t i = 0;
    while (i < edges.size()) {
        if (!edges[i].high) {
            ++i;  // polarity error: resync on the next HIGH
            continue;
        }
        const u32 high_ns = edges[i].ns;
        int bit = -1;
        if (i + 1 == edges.size()) {
            // The frame's last HIGH: its LOW is the reset, so classify by
            // HIGH width alone, like a mid-frame bit. (Stopping at the last
            // edge dropped the frame's final bit: LSB 1 decoded as 0.)
            bit = flexPwmBitFromMidpoint(high_ns, midpoint);
            i += 1;
        } else if (!edges[i + 1].high) {
            bit = flexPwmBitFromMidpoint(high_ns, midpoint);
            i += 2;
        } else {
            bit = flexPwmBitFromHigh(high_ns, timing);
            i += 1;
        }
        ++total_bits;
        if (bit < 0) {
            ++error_count;
            continue;
        }
        current_byte = static_cast<u8>((current_byte << 1) | static_cast<u8>(bit));
        if (++bit_count == 8) {
            if (byte_index >= bytes_out.size()) {
                return fl::result<u32, DecodeError>::failure(
                    DecodeError::BUFFER_OVERFLOW);
            }
            bytes_out[byte_index++] = current_byte;
            current_byte = 0;
            bit_count = 0;
        }
    }
 
    // Partial final byte, left-aligned.
    if (bit_count > 0 && byte_index < bytes_out.size()) {
        bytes_out[byte_index++] = static_cast<u8>(current_byte << (8 - bit_count));
    }
    if (total_bits > 0 && (error_count * 10) > total_bits) {
        return fl::result<u32, DecodeError>::failure(DecodeError::HIGH_ERROR_RATE);
    }
    return fl::result<u32, DecodeError>::success(byte_index);
}

References fl::BUFFER_OVERFLOW, fl::expected< T, E >::failure(), fl::FL_NO_EXCEPT, flexPwmAdaptiveMidpointNs(), flexPwmBitFromHigh(), flexPwmBitFromMidpoint(), flexPwmIsMidpointSample(), fl::HIGH_ERROR_RATE, and fl::expected< T, E >::success().

Here is the call graph for this function: