Enum Precision

pub enum Precision {
    Lazy,
    Accurate,
    Farnsworth(f32),
}

Decoding precision is either Lazy, Accurate or Farnsworth(speed_reduction_factor: f32).

If Lazy is selected, short and long signals will be considered to saturate their fields on the extreme ends. For example a short signal can be 1 ms to short range end and a long signal is from this point to the start of a very long (word separator) signal. If Accurate is selected, short and long signals will only be decoded correctly if they fall into a range of lower tolerance value and higher tolerance value. Default value for tolerance factor is 0.5. So if a short signal is expected to be 100 ms, correct decoding signal can be anywhere between 50 ms to 150 ms, but not 10 ms.

Default precision is Lazy, as it’s the most human friendly precision.

Farnsworth precision means extra delays will be added to spaces between characters and words but character decoding speed is not affected. Difference between current decoding speed and a reduced decoding speed will determine the length of the delays. The reduced decoding speed is determined by the factor value passed to the enum variant Farnsworth. This value will be multiplied by the current speed to find a reduction in overall speed. Factor value is clamped between 0.01 and 0.99.

Variants

Lazy

Accurate

Farnsworth(f32)

Trait Implementations

impl Debug for Precision

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Precision

fn eq(&self, other: &Precision) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Precision