provide rudimentary input_pins(), pull in some more methods useful in derived classes

Author: Sylvan Butler

Adafruit_GPIO/GPIO.py

@@ -55,12 +55,6 @@ def input(self, pin):
         or LOW/false if pulled low."""
         raise NotImplementedError
 
-    def input_pins(self, pins):
-        """Read multiple pins specified in the given list and return list of pin values
-        GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low.
-        """
-        raise NotImplementedError
-
     def set_high(self, pin):
         """Set the specified pin HIGH."""
         self.output(pin, HIGH)
@@ -77,26 +71,38 @@ def is_low(self, pin):
         """Return true if the specified pin is pulled low."""
         return self.input(pin) == LOW
 
+
+# Basic implementation of multiple pin methods just loops through pins and
+# processes each one individually. This is not optimal, but derived classes can
+# provide a more optimal implementation that deals with groups of pins
+# simultaneously.
+# See MCP230xx or PCF8574 classes for examples of optimized implementations.
+
     def output_pins(self, pins):
         """Set multiple pins high or low at once.  Pins should be a dict of pin
         name to pin value (HIGH/True for 1, LOW/False for 0).  All provided pins
         will be set to the given values.
         """
-        # General implementation just loops through pins and writes them out
-        # manually.  This is not optimized, but subclasses can choose to implement
-        # a more optimal batch output implementation.  See the MCP230xx class for
-        # example of optimized implementation.
+        # General implementation that can be optimized by derived classes.
         for pin, value in pins.iteritems():
             self.output(pin, value)
 
     def setup_pins(self, pins):
         """Setup multiple pins as inputs or outputs at once.  Pins should be a
         dict of pin name to pin type (IN or OUT).
         """
-        # General implementation that can be improved by subclasses.
+        # General implementation that can be optimized by derived classes.
         for pin, value in pins.iteritems():
             self.setup(pin, value)
 
+    def input_pins(self, pins):
+        """Read multiple pins specified in the given list and return list of pin values
+        GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low.
+        """
+        # General implementation that can be optimized by derived classes.
+        return [self.input(pin) for pin in pins]
+
+
     def add_event_detect(self, pin, edge):
         """Enable edge detection events for a particular GPIO channel.  Pin 
         should be type IN.  Edge must be RISING, FALLING or BOTH.
@@ -133,6 +139,19 @@ def cleanup(self, pin=None):
         """
         raise NotImplementedError
 
+
+# helper functions useful to derived classes
+
+    def _validate_pin(self, pin):
+        # Raise an exception if pin is outside the range of allowed values.
+        if pin < 0 or pin >= self.NUM_GPIO:
+            raise ValueError('Invalid GPIO value, must be between 0 and {0}.'.format(self.NUM_GPIO))
+
+    def _bit2(self, src, bit, val):
+        bit = 1 << bit
+        return (src | bit) if val else (src & ~bit)
+
+
 class RPiGPIOAdapter(BaseGPIO):
     """GPIO implementation for the Raspberry Pi using the RPi.GPIO library."""