In response to comments

Author: dastels

adafruit_debouncer.py

@@ -47,85 +47,78 @@
 
 import time
 import digitalio
-import microcontroller
+
+_DEBOUNCED_STATE = 0x01
+_UNSTABLE_STATE = 0x02
+_CHANGED_STATE = 0x04
 
 class Debouncer(object):
     """Debounce an input pin or an arbitrary predicate"""
 
-    DEBOUNCED_STATE = 0x01
-    UNSTABLE_STATE = 0x02
-    CHANGED_STATE = 0x04
-
-
-    def __init__(self, pin_or_predicate, mode=None, interval=0.010):
+    def __init__(self, io_or_predicate, interval=0.010):
         """Make am instance.
-           :param int/function pin_or_predicate: the pin (from board) to debounce
-           :param int mode: digitalio.Pull.UP or .DOWN (default is no pull up/down)
+           :param DigitalInOut/function io_or_predicate: the pin (from board) to debounce
            :param int interval: bounce threshold in seconds (default is 0.010, i.e. 10 milliseconds)
         """
         self.state = 0x00
-        if isinstance(pin_or_predicate, microcontroller.Pin):
-            pin = digitalio.DigitalInOut(pin_or_predicate)
-            pin.direction = digitalio.Direction.INPUT
-            if mode is not None:
-                pin.pull = mode
-            self.function = lambda: pin.value
+        if isinstance(io_or_predicate, digitalio.DigitalInOut):
+            self.function = lambda: io_or_predicate.value
         else:
-            self.function = pin_or_predicate
+            self.function = io_or_predicate
         if self.function():
-            self.__set_state(Debouncer.DEBOUNCED_STATE | Debouncer.UNSTABLE_STATE)
+            self._set_state(_DEBOUNCED_STATE | _UNSTABLE_STATE)
         self.previous_time = 0
         if interval is None:
             self.interval = 0.010
         else:
             self.interval = interval
 
 
-    def __set_state(self, bits):
+    def _set_state(self, bits):
         self.state |= bits
 
 
-    def __unset_state(self, bits):
+    def _unset_state(self, bits):
         self.state &= ~bits
 
 
-    def __toggle_state(self, bits):
+    def _toggle_state(self, bits):
         self.state ^= bits
 
 
-    def __get_state(self, bits):
+    def _get_state(self, bits):
         return (self.state & bits) != 0
 
 
     def update(self):
         """Update the debouncer state. MUST be called frequently"""
         now = time.monotonic()
-        self.__unset_state(Debouncer.CHANGED_STATE)
+        self._unset_state(_CHANGED_STATE)
         current_state = self.function()
-        if current_state != self.__get_state(Debouncer.UNSTABLE_STATE):
+        if current_state != self._get_state(_UNSTABLE_STATE):
             self.previous_time = now
-            self.__toggle_state(Debouncer.UNSTABLE_STATE)
+            self._toggle_state(_UNSTABLE_STATE)
         else:
             if now - self.previous_time >= self.interval:
-                if current_state != self.__get_state(Debouncer.DEBOUNCED_STATE):
+                if current_state != self._get_state(_DEBOUNCED_STATE):
                     self.previous_time = now
-                    self.__toggle_state(Debouncer.DEBOUNCED_STATE)
-                    self.__set_state(Debouncer.CHANGED_STATE)
+                    self._toggle_state(_DEBOUNCED_STATE)
+                    self._set_state(_CHANGED_STATE)
 
 
     @property
     def value(self):
         """Return the current debounced value."""
-        return self.__get_state(Debouncer.DEBOUNCED_STATE)
+        return self._get_state(_DEBOUNCED_STATE)
 
 
     @property
     def rose(self):
         """Return whether the debounced value went from low to high at the most recent update."""
-        return self.__get_state(self.DEBOUNCED_STATE) and self.__get_state(self.CHANGED_STATE)
+        return self._get_state(_DEBOUNCED_STATE) and self._get_state(_CHANGED_STATE)
 
 
     @property
     def fell(self):
         """Return whether the debounced value went from high to low at the most recent update."""
-        return (not self.__get_state(self.DEBOUNCED_STATE)) and self.__get_state(self.CHANGED_STATE)
+        return (not self._get_state(_DEBOUNCED_STATE)) and self._get_state(_CHANGED_STATE)

docs/conf.py

@@ -20,7 +20,7 @@
 # Uncomment the below if you use native CircuitPython modules such as
 # digitalio, micropython and busio. List the modules you use. Without it, the
 # autodoc module docs will fail to generate with a warning.
-autodoc_mock_imports = ["digitalio", "microcontroller"]
+autodoc_mock_imports = ["digitalio"]
 
 
 intersphinx_mapping = {'python': ('https://docs.python.org/3.4', None),'CircuitPython': ('https://circuitpython.readthedocs.io/en/latest/', None)}

examples/debouncer_crickit_test.py

@@ -34,17 +34,17 @@
 
 ss = crickit.seesaw
 
-def make_criket_signal_debouncer(pin):
+def make_crikit_signal_debouncer(pin):
     """Return a lambda to read the specified pin"""
     ss.pin_mode(pin, ss.INPUT_PULLUP)
     return Debouncer(lambda: ss.digital_read(pin))
 
 # Two buttons are pullups, connect to ground to activate
-clock = make_criket_signal_debouncer(crickit.SIGNAL1)
-signal_2 = make_criket_signal_debouncer(crickit.SIGNAL2)
-signal_3 = make_criket_signal_debouncer(crickit.SIGNAL3)
-signal_4 = make_criket_signal_debouncer(crickit.SIGNAL4)
-signal_5 = make_criket_signal_debouncer(crickit.SIGNAL5)
+clock = make_crikit_signal_debouncer(crickit.SIGNAL1)
+signal_2 = make_crikit_signal_debouncer(crickit.SIGNAL2)
+signal_3 = make_crikit_signal_debouncer(crickit.SIGNAL3)
+signal_4 = make_crikit_signal_debouncer(crickit.SIGNAL4)
+signal_5 = make_crikit_signal_debouncer(crickit.SIGNAL5)
 
 while True:
     clock.update()

examples/debouncer_simpletest.py

@@ -25,10 +25,13 @@
 # pylint: disable=invalid-name
 
 import board
-from digitalio import Pull
+import digitalio
 from adafruit_debouncer import Debouncer
 
-switch = Debouncer(board.D12, Pull.UP)
+pin = digitalio.DigitalInOut(board.D12)
+pin.direction = digitalio.Direction.INPUT
+pin.pull = digitalio.Pull.UP
+switch = Debouncer(pin)
 
 while True:
     switch.update()