bounced 0.2.0

Debouncing and Testing for Signals and Buttons
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

use crate::{
	active::Active,
	strategy::{NumericType, Strategy},
	Status,
};
use core::cell::Cell;

/// # Shift Strategy for Debouncing
/// Uses a shift operation (counter) to determine if an input has stabilized
///
/// If the register is [`NumericType::MIN`], the input is stable low. If it is
/// [`NumericType::MAX`] the input is stable high. The shift starts as
/// stable on the [inactive](trait@Active) value.
///
/// Anywhere in-between min and max is unstable (`None`).
///
/// ## Comparison to [`Integrator`](crate::strategy::Integrator)
/// - more coding overhead to customize the unstable zone (requires NewType)
/// - is more space efficient since `MAX` is an associated constant, not a
///   stored value
#[repr(transparent)]
pub struct Shifter<T> {
	reg: Cell<T>,
}

impl<T> Shifter<T>
where
	T: NumericType,
{
	/// Create a new Shifter
	pub fn new<A: Active>() -> Self {
		Self {
			reg: Cell::new(if A::ACTIVE_VALUE == Status::Low {
				T::MAX
			} else {
				T::MIN
			}),
		}
	}
}

impl<T> Strategy for Shifter<T>
where
	T: NumericType + core::fmt::Debug,
{
	fn status(&self) -> Option<Status> {
		let reg = self.reg.get();
		if reg <= T::MIN {
			Some(Status::Low)
		} else if reg >= T::MAX {
			Some(Status::High)
		} else {
			None
		}
	}

	fn update(&self, status: Status) -> Option<Status> {
		let reg = self.reg.get();
		match status {
			Status::Low if reg > T::MIN => {
				self.reg.set(reg >> 1);
			}
			Status::High if reg < T::MAX => {
				self.reg.set(reg << 1);
			}
			_ => {}
		}
		self.status()
	}
}

#[cfg(test)]
mod tests {
	use super::*;
	use crate::active::{High, Low};

	#[test]
	fn update_progress() {
		let i = Shifter::<u8>::new::<Low>();
		assert_eq!(i.status(), Some(Status::High));
		assert_eq!(i.update(Status::High), Some(Status::High));
		assert_eq!(i.update(Status::Low), None);
		assert_eq!(i.update(Status::Low), None);
		assert_eq!(i.update(Status::Low), None);
		assert_eq!(i.update(Status::Low), None);
		assert_eq!(i.update(Status::Low), None);
		assert_eq!(i.update(Status::Low), None);
		assert_eq!(i.update(Status::Low), Some(Status::Low));
		assert_eq!(i.update(Status::Low), Some(Status::Low));
		assert_eq!(i.update(Status::High), None);
		assert_eq!(i.update(Status::High), None);
		assert_eq!(i.update(Status::High), None);
		assert_eq!(i.update(Status::High), None);
		assert_eq!(i.update(Status::High), None);
		assert_eq!(i.update(Status::High), None);
		assert_eq!(i.update(Status::High), Some(Status::High));
		assert_eq!(i.update(Status::High), Some(Status::High));
	}

	#[test]
	fn update_high() {
		let i = Shifter::<u8>::new::<High>();
		assert_eq!(i.status(), Some(Status::Low));
	}
	#[test]
	fn update_low() {
		let i = Shifter::<u8>::new::<Low>();
		assert_eq!(i.status(), Some(Status::High));
	}
}