decodeWs2812Edges()

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

Decode a WS2812 edge-pair stream into bytes.

Parameters

timing	4-phase timing thresholds (T0H/T0L/T1H/T1L windows + reset).
edges	Captured edge stream. Each WS2812 bit is one HIGH edge followed by one LOW edge, both labelled with their duration in ns.
out	Destination byte buffer. MSB-first per WS2812 wire order.

Returns

Number of decoded bytes on success, or a DecodeError on buffer overflow / >10 % error rate. An empty edges span returns INVALID_ARGUMENT so callers can distinguish "no data captured" from "captured but garbage".

Definition at line 17 of file decode_ws2812.cpp.hpp.

                                              {
    const size_t edge_count = edges.size();
    if (edge_count == 0) {
        return fl::result<u32, DecodeError>::failure(DecodeError::INVALID_ARGUMENT);
    }
 
    size_t bytes_written = 0;
    size_t bit_index = 0;
    u8 current_byte = 0;
    u32 error_count = 0;
 
    size_t i = 0;
    while (i + 1 < edge_count) {
        const EdgeTime high_edge = edges[i];
        const EdgeTime low_edge  = edges[i + 1];
 
        if (!high_edge.high || low_edge.high) {
            error_count++;
            i++;
            continue;
        }
 
        const u32 high_ns = high_edge.ns;
        const u32 low_ns  = low_edge.ns;
 
        bool is_bit1 = (high_ns >= timing.t1h_min_ns && high_ns <= timing.t1h_max_ns &&
                        low_ns  >= timing.t1l_min_ns && low_ns  <= timing.t1l_max_ns);
        bool is_bit0 = (high_ns >= timing.t0h_min_ns && high_ns <= timing.t0h_max_ns &&
                        low_ns  >= timing.t0l_min_ns && low_ns  <= timing.t0l_max_ns);
 
        if (!is_bit0 && !is_bit1) {
            if (low_ns >= static_cast<u32>(timing.reset_min_us) * 1000u) {
                break;  // WS2812 reset pulse -> end of frame
            }
            if (timing.gap_tolerance_ns > 0 && low_ns <= timing.gap_tolerance_ns) {
                if (high_ns >= timing.t1h_min_ns && high_ns <= timing.t1h_max_ns) {
                    is_bit1 = true;
                } else if (high_ns >= timing.t0h_min_ns && high_ns <= timing.t0h_max_ns) {
                    is_bit0 = true;
                }
            }
            if (!is_bit0 && !is_bit1) {
                error_count++;
                i += 2;
                continue;
            }
        }
 
        const u8 bit = is_bit1 ? u8{1} : u8{0};
        current_byte = static_cast<u8>((current_byte << 1) | bit);
        bit_index++;
 
        if (bit_index == 8) {
            if (bytes_written >= out.size()) {
                return fl::result<u32, DecodeError>::failure(DecodeError::BUFFER_OVERFLOW);
            }
            out[bytes_written++] = current_byte;
            current_byte = 0;
            bit_index = 0;
        }
 
        i += 2;
    }
 
    if (bytes_written > 0 && error_count * 10 > bytes_written * 8) {
        return fl::result<u32, DecodeError>::failure(DecodeError::HIGH_ERROR_RATE);
    }
 
    return fl::result<u32, DecodeError>::success(static_cast<u32>(bytes_written));
}

References fl::BUFFER_OVERFLOW, fl::expected< T, E >::failure(), FL_NOEXCEPT, fl::EdgeTime::high, fl::HIGH_ERROR_RATE, fl::INVALID_ARGUMENT, fl::EdgeTime::ns, and fl::expected< T, E >::success().

Here is the call graph for this function: