pot-head 0.2.1

A no_std Rust library for processing raw potmeter inputs in embedded systems
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use pot_head::{Config, HysteresisMode, NoiseFilter, PotHead, ResponseCurve, SnapZone};

#[cfg(feature = "grab-mode")]
use pot_head::GrabMode;

static EMPTY_SNAP_ZONES: [SnapZone<f32>; 0] = [];

#[test]
fn test_u16_to_u16_normalization() {
    static CONFIG: Config<u16, u16> = Config {
        input_min: 0_u16,
        input_max: 4095_u16,
        output_min: 0_u16,
        output_max: 255_u16,
        hysteresis: HysteresisMode::none(),
        curve: ResponseCurve::Linear,
        filter: NoiseFilter::None,
        snap_zones: &EMPTY_SNAP_ZONES,
        #[cfg(feature = "grab-mode")]
        grab_mode: GrabMode::None,
    };

    let mut pot = PotHead::new(&CONFIG).unwrap();

    // Test minimum
    assert_eq!(pot.process(0), 0);

    // Test maximum
    assert_eq!(pot.process(4095), 255);

    // Test middle (should be approximately 127-128)
    let mid = pot.process(2047);
    assert!(mid >= 127 && mid <= 128, "Middle value was {}", mid);

    // Test quarter point
    let quarter = pot.process(1023);
    assert!(
        quarter >= 63 && quarter <= 64,
        "Quarter value was {}",
        quarter
    );
}

#[test]
fn test_u16_to_f32_normalization() {
    static CONFIG: Config<u16, f32> = Config {
        input_min: 0_u16,
        input_max: 4095_u16,
        output_min: 0.0_f32,
        output_max: 1.0_f32,
        hysteresis: HysteresisMode::none(),
        curve: ResponseCurve::Linear,
        filter: NoiseFilter::None,
        snap_zones: &EMPTY_SNAP_ZONES,
        #[cfg(feature = "grab-mode")]
        grab_mode: GrabMode::None,
    };

    let mut pot = PotHead::new(&CONFIG).unwrap();

    // Test minimum
    assert_eq!(pot.process(0), 0.0);

    // Test maximum
    assert_eq!(pot.process(4095), 1.0);

    // Test middle
    let mid = pot.process(2047);
    assert!((mid - 0.5).abs() < 0.01, "Middle value was {}", mid);

    // Test quarter
    let quarter = pot.process(1023);
    assert!(
        (quarter - 0.25).abs() < 0.01,
        "Quarter value was {}",
        quarter
    );
}

#[test]
fn test_input_clamping() {
    static CONFIG: Config<u16, f32> = Config {
        input_min: 100_u16,
        input_max: 200_u16,
        output_min: 0.0_f32,
        output_max: 1.0_f32,
        hysteresis: HysteresisMode::none(),
        curve: ResponseCurve::Linear,
        filter: NoiseFilter::None,
        snap_zones: &EMPTY_SNAP_ZONES,
        #[cfg(feature = "grab-mode")]
        grab_mode: GrabMode::None,
    };

    let mut pot = PotHead::new(&CONFIG).unwrap();

    // Test below minimum gets clamped
    assert_eq!(pot.process(50), 0.0);

    // Test above maximum gets clamped
    assert_eq!(pot.process(300), 1.0);

    // Test within range
    assert_eq!(pot.process(150), 0.5);
}

#[test]
fn test_inverted_output_range() {
    static CONFIG: Config<u16, f32> = Config {
        input_min: 0_u16,
        input_max: 100_u16,
        output_min: 1.0_f32,
        output_max: 0.0_f32,
        hysteresis: HysteresisMode::none(),
        curve: ResponseCurve::Linear,
        filter: NoiseFilter::None,
        snap_zones: &EMPTY_SNAP_ZONES,
        #[cfg(feature = "grab-mode")]
        grab_mode: GrabMode::None,
    };

    let mut pot = PotHead::new(&CONFIG).unwrap();

    // When input is minimum, output should be maximum (inverted)
    assert_eq!(pot.process(0), 1.0);

    // When input is maximum, output should be minimum (inverted)
    assert_eq!(pot.process(100), 0.0);

    // Middle should be 0.5
    let mid = pot.process(50);
    assert!((mid - 0.5).abs() < 0.01, "Middle value was {}", mid);
}

#[test]
fn test_same_type_conversion() {
    static CONFIG: Config<f32, f32> = Config {
        input_min: 0_f32,
        input_max: 1.0_f32,
        output_min: 0.0_f32,
        output_max: 100.0_f32,
        hysteresis: HysteresisMode::none(),
        curve: ResponseCurve::Linear,
        filter: NoiseFilter::None,
        snap_zones: &EMPTY_SNAP_ZONES,
        #[cfg(feature = "grab-mode")]
        grab_mode: GrabMode::None,
    };

    let mut pot = PotHead::new(&CONFIG).unwrap();

    assert_eq!(pot.process(0.0), 0.0);
    assert_eq!(pot.process(1.0), 100.0);
    assert_eq!(pot.process(0.5), 50.0);
}