Merge pull request #101 from twinters007/toggle

Fixup and add toggle to docs

Author: virtuald

docs/magicbot.rst

@@ -26,7 +26,7 @@ Tunable
     :show-inheritance:
 
 Resettable
-~~~~~
+~~~~~~~~~~
 
 .. automodule:: magicbot.magic_reset
     :members:

docs/robotpy_ext.control.rst

@@ -8,6 +8,12 @@ robotpy_ext.control.button_debouncer module
     :members:
     :undoc-members:
 
+robotpy_ext.control.toggle module
+---------------------------------
+
+.. automodule:: robotpy_ext.control.toggle
+    :members:
+    :undoc-members:
 
 robotpy_ext.control.xbox_controller module
 ------------------------------------------

robotpy_ext/control/toggle.py

@@ -1,11 +1,12 @@
 from _functools import partial
-from wpilib.timer import Timer
+
+import wpilib
 
 
 class Toggle:
-    """Utility class for button toggle
+    """Utility class for joystick button toggle
 
-        Usage:
+    Usage::
 
         foo = Toggle(joystick, 3)
 
@@ -19,43 +20,39 @@ class Toggle:
             offToggle()
     """
     class _SteadyDebounce:
-        '''
+        """
             Similar to ButtonDebouncer, but the output stays steady for
             the given periodic_filter. E.g, if you set the period to 2
             and press the button, the value will return true for 2 seconds.
 
             Steady debounce will return true for the given period, allowing it to be
             used with Toggle
-        '''
+        """
 
-        def __init__(self, joystick, button, period=0.5):
-            '''
+        def __init__(self, joystick: wpilib.Joystick, button: int, period: float):
+            """
             :param joystick:  Joystick object
             :type  joystick:  :class:`wpilib.Joystick`
             :param button: Number of button to retrieve
             :type  button: int
             :param period:    Period of time (in seconds) to wait before allowing new button
                               presses. Defaults to 0.5 seconds.
             :type  period:    float
-            '''
+            """
             self.joystick = joystick
             self.button = button
 
             self.debounce_period = float(period)
             self.latest = - self.debounce_period # Negative latest prevents get from returning true until joystick is presed for the first time
-            self.timer = Timer
             self.enabled = False
 
-        def set_debounce_period(self, period):
-            '''Set number of seconds to hold return value'''
-            self.debounce_period = float(period)
-
         def get(self):
-            '''Returns the value of the joystick button. Once the button is pressed,
-            the return value will be True until the time expires
-            '''
+            """
+            :returns: The value of the joystick button. Once the button is pressed,
+            the return value will be `True` until the time expires
+            """
 
-            now = self.timer.getFPGATimestamp()
+            now = wpilib.Timer.getFPGATimestamp()
             if now - self.latest < self.debounce_period:
                 return True
 
@@ -65,17 +62,18 @@ def get(self):
             else:
                 return False
 
-    def __init__(self, joystick, button, debouncePeriod=None):
+    def __init__(self, joystick: wpilib.Joystick, button: int, debounce_period: float=None):
         """
-        :param joystick: wpilib.Joystick that contains the button to toggle
-        :param button: Value of button that will act as toggle. Same value used in getRawButton()
+        :param joystick: :class:`wpilib.Joystick` that contains the button to toggle
+        :param button: Number of button that will act as toggle. Same value used in `getRawButton()`
+        :param debounce_period: Period in seconds to wait before registering a new button press.
         """
 
-        if debouncePeriod is not None:
-            self.joystick = Toggle._SteadyDebounce(joystick, button, debouncePeriod)
+        if debounce_period is not None:
+            self.joystickget = Toggle._SteadyDebounce(joystick, button, debounce_period).get
         else:
             self.joystick = joystick
-            self.joystick.get = partial(self.joystick.getRawButton, button)
+            self.joystickget = partial(self.joystick.getRawButton, button)
 
         self.released = False
         self.toggle = False
@@ -86,7 +84,7 @@ def get(self):
          :return: State of toggle
          :rtype: bool
          """
-        current_state = self.joystick.get()
+        current_state = self.joystickget()
 
         if current_state and not self.released:
             self.released = True
@@ -100,11 +98,17 @@ def get(self):
 
     @property
     def on(self):
+        """
+        Equates to true if toggle is in the 'on' state
+        """
         self.get()
         return self.state
 
     @property
     def off(self):
+        """
+        Equates to true if toggle is in the 'off' state
+        """
         self.get()
         return not self.state
 

tests/test_toggle.py

@@ -2,43 +2,48 @@
 from robotpy_ext.misc.precise_delay import PreciseDelay
 class FakeJoystick:
     def __init__(self):
-        self._pressed = False 
-    
+        self._pressed = [False] * 2
+
     def getRawButton(self, num):
-        return self._pressed
+        return self._pressed[num]
 
-    def press(self):
-        self._pressed = True
+    def press(self, num):
+        self._pressed[num] = True
 
-    def release(self):
-        self._pressed = False
+    def release(self, num):
+        self._pressed[num] = False
 
 def test_toggle():
     joystick = FakeJoystick()
-    toggleButton = Toggle(joystick, 1)
+    toggleButton = Toggle(joystick, 0)
+    toggleButton2 = Toggle(joystick, 1)
     assert toggleButton.off
-    joystick.press()
+    joystick.press(0)
     assert toggleButton.on
-    joystick.release()
+    assert toggleButton2.off
+    joystick.release(0)
     assert toggleButton.on
-    joystick.press()
+    joystick.press(0)
+    assert toggleButton.off
+    joystick.release(0)
     assert toggleButton.off
-    joystick.release()
+    joystick.press(1)
     assert toggleButton.off
+    assert toggleButton2.on
 
 
 def test_toggle_debounce():
     delay = PreciseDelay(2.1)
     joystick = FakeJoystick()
     toggleButton = Toggle(joystick, 1, 2)
     assert toggleButton.off
-    joystick.press()
+    joystick.press(1)
     assert toggleButton.on
-    joystick.release()
-    joystick.press()
-    joystick.release()
+    joystick.release(1)
+    joystick.press(1)
+    joystick.release(1)
     assert toggleButton.on
     delay.wait()
     assert toggleButton.on
-    joystick.press()
+    joystick.press(1)
     assert toggleButton.off