quadrature-decoder 0.2.0

Pure logic-level implementations of quadrature decoders with support for full-, half- an quad-stepping.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

use quadrature_decoder::{FullStep, HalfStep, IndexedIncrementalDecoder, QuadStep, StepMode};

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!();
    }
}

fn main() {
    let a: Vec<bool> = vec![false, false, true, true, false, false, true, true];
    let b: Vec<bool> = vec![true, false, false, true, true, false, false, true];
    let z: Vec<bool> = vec![false, false, false, false, true, false, false, false];

    println!("Full-step decoder:");
    let mut full_step_decoder = IndexedIncrementalDecoder::<FullStep>::default();
    decode(
        &mut full_step_decoder,
        a.iter()
            .cloned()
            .zip(b.iter().cloned())
            .zip(z.iter().cloned()),
    );
    println!();

    println!("Half-step decoder:");
    let mut half_step_decoder = IndexedIncrementalDecoder::<HalfStep>::default();
    decode(
        &mut half_step_decoder,
        a.iter()
            .cloned()
            .zip(b.iter().cloned())
            .zip(z.iter().cloned()),
    );
    println!();

    println!("Quad-step decoder:");
    let mut quad_step_decoder = IndexedIncrementalDecoder::<QuadStep>::default();
    decode(
        &mut quad_step_decoder,
        a.iter()
            .cloned()
            .zip(b.iter().cloned())
            .zip(z.iter().cloned()),
    );
    println!();
}