buildWave8ExpansionLUT()

FL_OPTIMIZE_FUNCTION Wave8BitExpansionLut fl::buildWave8ExpansionLUT

(

const ChipsetTiming &

timing

)

Build a Wave8BitExpansionLut from chipset timing data.

Converts three-phase LED timing (T1, T2, T3) into a nibble lookup table for 8-pulse-per-bit waveform expansion. The timing is normalized to a period of 1.0 and mapped to 8 pulses per bit (packed into 1 byte).

Never call this from ISR handlers. This is something that should be called before entering ISR context.

Parameters

timing

ChipsetTiming struct containing T1, T2, T3 in nanoseconds

Returns

Populated Wave8BitExpansionLut lookup table (64 bytes)

Definition at line 250 of file wave8.cpp.hpp.

                                                                         {
    Wave8BitExpansionLut lut;
 
    // Step 1: Calculate absolute times from ChipsetTiming format
    // ChipsetTiming.T1 = T0H (high time for bit 0)
    // ChipsetTiming.T2 = T1H - T0H (ADDITIONAL high time for bit 1)
    // ChipsetTiming.T3 = T0L (low tail duration)
    const u32 t0h = timing.T1;                     // T0H: bit 0 goes LOW here
    const u32 t1h = timing.T1 + timing.T2;          // T1H: bit 1 goes LOW here
    const u32 period = timing.T1 + timing.T2 + timing.T3; // Total period
 
    // Step 2: Normalize absolute times
    const float t0h_norm = static_cast<float>(t0h) / period;
    const float t1h_norm = static_cast<float>(t1h) / period;
 
    // Step 3: Convert to pulse counts (fixed 8 pulses per bit)
    // pulses_bit0: number of HIGH pulses for bit 0 (before it goes LOW at t0h)
    // pulses_bit1: number of HIGH pulses for bit 1 (before it goes LOW at t1h)
    u32 pulses_bit0 =
        static_cast<u32>(t0h_norm * 8.0f + 0.5f); // round
    u32 pulses_bit1 =
        static_cast<u32>(t1h_norm * 8.0f + 0.5f); // round
 
    // Clamp to valid range [0, 8]
    if (pulses_bit0 > 8)
        pulses_bit0 = 8;
    if (pulses_bit1 > 8)
        pulses_bit1 = 8;
 
    // Step 4: Generate bit0 and bit1 waveforms (1 byte each, packed format)
    // Each bit represents one pulse (MSB = first pulse)
    u8 bit0_waveform = 0;
    u8 bit1_waveform = 0;
 
    // Bit 0: Set MSB bits for HIGH pulses
    for (u32 i = 0; i < pulses_bit0; i++) {
        bit0_waveform |= (0x80 >> i);  // Set bit from MSB
    }
 
    // Bit 1: Set MSB bits for HIGH pulses
    for (u32 i = 0; i < pulses_bit1; i++) {
        bit1_waveform |= (0x80 >> i);  // Set bit from MSB
    }
 
    // Step 5: Build LUT for all 16 nibbles
    for (u8 nibble = 0; nibble < 16; nibble++) {
        // For each nibble, generate 4 Wave8Bit (one per bit, MSB first)
        for (int bit_pos = 3; bit_pos >= 0; bit_pos--) {
            // Extract bit (MSB first: bit 3, 2, 1, 0)
            const bool bit_set = (nibble >> bit_pos) & 1;
            const u8 waveform = bit_set ? bit1_waveform : bit0_waveform;
 
            // Store packed waveform to LUT entry
            lut.lut[nibble][3 - bit_pos].data = waveform;
        }
    }
 
    return lut;
}

References fl::ChipsetTiming::T1, fl::ChipsetTiming::T2, and fl::ChipsetTiming::T3.