Struct IndexedIncrementalDecoder

pub struct IndexedIncrementalDecoder<Mode, T = i32> { /* private fields */ }

A robust indexed quadrature decoder with support for multiple step-modes, based on which channel (A vs. B) is leading the other.

               ┌ ─ ┐   ┌───┐   ┌───┐   ┌───┐   ┌ ─ ─ high
           A           │   │   │   │   │                  
             ─ ┘   └───┘   └───┘   └───┘   └ ─ ┘     low  
AB:                                                  
                 ┌ ─ ┐   ┌───┐   ┌───┐   ┌───┐   ┌ ─ high
           B             │   │   │   │   │                
             ─ ─ ┘   └───┘   └───┘   └───┘   └ ─ ┘   low  

                         ┌─┐                         high
           Z             │ │                              
             ─ ─ ─ ──────┘ └────────────────── ─ ─ ─ low  
Time: ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─▶
                 ┌ ─ ┐   ┌───┐   ┌───┐   ┌───┐   ┌ ─ high
           A             │   │   │   │   │                
             ─ ─ ┘   └───┘   └───┘   └───┘   └ ─ ┘   low  
BA:                                                  
               ┌ ─ ┐   ┌───┐   ┌───┐   ┌───┐   ┌ ─ ─ high
           B           │   │   │   │   │                  
             ─ ┘   └───┘   └───┘   └───┘   └ ─ ┘     low  

                         ┌─┐                         high
           Z             │ │                              
             ─ ─ ─ ──────┘ └────────────────── ─ ─ ─ low  

Implementations

impl<Mode, T> IndexedIncrementalDecoder<Mode, T>

where Mode: StepMode, T: Copy + Zero + One + SaturatingAdd + From<i8>,

pub fn update( &mut self, a: bool, b: bool, z: bool, ) -> Result<Option<Change>, Error>

Updates the decoder’s state based on the given a and b pulse train (aka channel) readings, returning the direction if a change was detected, None if no change was detected, or Err(_) if an invalid input (i.e. a counteral “jump”) was detected.

Upon detection of a raising edge on the z pulse train the counter gets reset back to 0.

Depending on whether it matters why the decoder did not detect a change (e.g. due to actual lack of change or an erroneous read) you would either call decoder.update(a, b) directly, or via decoder.update(a, b).unwrap_or_default() to fall back to None in case of Err(_).

Examples found in repository

examples/indexed_incremental.rs (line 13)

fn decode<S, I>(decoder: &mut IndexedIncrementalDecoder<S>, pulse_trains: I)
where
    S: StepMode,
    I: Iterator<Item = ((bool, bool), bool)>,
{
    println!("Decoder is at counter: {:?}.", decoder.counter());
    println!();

    for ((a, b), z) in pulse_trains {
        println!("Reading pulses: (a: {a:?}, b: {b:?}, z: {z:?})");
        match decoder.update(a, b, z) {
            Ok(Some(change)) => println!("Change detected: {:?}.", change),
            Ok(None) => println!("No change detected."),
            Err(error) => println!("Error detected: {:?}.", error),
        }
        println!("Decoder is at counter: {:?}.", decoder.counter());
        println!();
    }
}

pub fn reset(&mut self)

Resets the decoder to its initial state and its counter counter back to 0.

pub fn counter(&self) -> T

Returns the decoder’s counter counter relative to its initial counter in number of cycles.

A change of Change::Positive increments the counter counter, while a change of Change::Negative decrements it.

Examples found in repository

examples/indexed_incremental.rs (line 8)

fn decode<S, I>(decoder: &mut IndexedIncrementalDecoder<S>, pulse_trains: I)
where
    S: StepMode,
    I: Iterator<Item = ((bool, bool), bool)>,
{
    println!("Decoder is at counter: {:?}.", decoder.counter());
    println!();

    for ((a, b), z) in pulse_trains {
        println!("Reading pulses: (a: {a:?}, b: {b:?}, z: {z:?})");
        match decoder.update(a, b, z) {
            Ok(Some(change)) => println!("Change detected: {:?}.", change),
            Ok(None) => println!("No change detected."),
            Err(error) => println!("Error detected: {:?}.", error),
        }
        println!("Decoder is at counter: {:?}.", decoder.counter());
        println!();
    }
}

pub fn set_counter(&mut self, counter: T)

Sets the decoder’s counter.

Trait Implementations

impl<Mode: Debug, T: Debug> Debug for IndexedIncrementalDecoder<Mode, T>

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

Formats the value using the given formatter.

impl<Mode, T> Default for IndexedIncrementalDecoder<Mode, T>

where Mode: StepMode, IncrementalDecoder<Mode, T>: Default,

fn default() -> Self

Returns the “default value” for a type.