293 lines
11 KiB
Python
293 lines
11 KiB
Python
# Copyright (c) 2014 Adafruit Industries
|
|
# Author: Tony DiCola
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
# of this software and associated documentation files (the "Software"), to deal
|
|
# in the Software without restriction, including without limitation the rights
|
|
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
# copies of the Software, and to permit persons to whom the Software is
|
|
# furnished to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included in
|
|
# all copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
# THE SOFTWARE.
|
|
|
|
import Adafruit_GPIO.Platform as Platform
|
|
|
|
|
|
OUT = 0
|
|
IN = 1
|
|
HIGH = True
|
|
LOW = False
|
|
|
|
RISING = 1
|
|
FALLING = 2
|
|
BOTH = 3
|
|
|
|
PUD_OFF = 0
|
|
PUD_DOWN = 1
|
|
PUD_UP = 2
|
|
|
|
class BaseGPIO(object):
|
|
"""Base class for implementing simple digital IO for a platform.
|
|
Implementors are expected to subclass from this and provide an implementation
|
|
of the setup, output, and input functions."""
|
|
|
|
def setup(self, pin, mode, pull_up_down=PUD_OFF):
|
|
"""Set the input or output mode for a specified pin. Mode should be
|
|
either OUT or IN."""
|
|
raise NotImplementedError
|
|
|
|
def output(self, pin, value):
|
|
"""Set the specified pin the provided high/low value. Value should be
|
|
either HIGH/LOW or a boolean (true = high)."""
|
|
raise NotImplementedError
|
|
|
|
def input(self, pin):
|
|
"""Read the specified pin and return HIGH/true if the pin is pulled high,
|
|
or LOW/false if pulled low."""
|
|
raise NotImplementedError
|
|
|
|
def set_high(self, pin):
|
|
"""Set the specified pin HIGH."""
|
|
self.output(pin, HIGH)
|
|
|
|
def set_low(self, pin):
|
|
"""Set the specified pin LOW."""
|
|
self.output(pin, LOW)
|
|
|
|
def is_high(self, pin):
|
|
"""Return true if the specified pin is pulled high."""
|
|
return self.input(pin) == HIGH
|
|
|
|
def is_low(self, pin):
|
|
"""Return true if the specified pin is pulled low."""
|
|
return self.input(pin) == LOW
|
|
|
|
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.
|
|
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.
|
|
for pin, value in pins.iteritems():
|
|
self.setup(pin, value)
|
|
|
|
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.
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
def remove_event_detect(self, pin):
|
|
"""Remove edge detection for a particular GPIO channel. Pin should be
|
|
type IN.
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
def add_event_callback(self, pin, callback):
|
|
"""Add a callback for an event already defined using add_event_detect().
|
|
Pin should be type IN.
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
def event_detected(self, pin):
|
|
"""Returns True if an edge has occured on a given GPIO. You need to
|
|
enable edge detection using add_event_detect() first. Pin should be
|
|
type IN.
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
def wait_for_edge(self, pin, edge):
|
|
"""Wait for an edge. Pin should be type IN. Edge must be RISING,
|
|
FALLING or BOTH."""
|
|
raise NotImplementedError
|
|
|
|
class RPiGPIOAdapter(BaseGPIO):
|
|
"""GPIO implementation for the Raspberry Pi using the RPi.GPIO library."""
|
|
|
|
def __init__(self, rpi_gpio, mode=None):
|
|
self.rpi_gpio = rpi_gpio
|
|
# Suppress warnings about GPIO in use.
|
|
rpi_gpio.setwarnings(False)
|
|
# Setup board pin mode.
|
|
if mode == rpi_gpio.BOARD or mode == rpi_gpio.BCM:
|
|
rpi_gpio.setmode(mode)
|
|
elif mode is not None:
|
|
raise ValueError('Unexpected value for mode. Must be BOARD or BCM.')
|
|
else:
|
|
# Default to BCM numbering if not told otherwise.
|
|
rpi_gpio.setmode(rpi_gpio.BCM)
|
|
# Define mapping of Adafruit GPIO library constants to RPi.GPIO constants.
|
|
self._dir_mapping = { OUT: rpi_gpio.OUT,
|
|
IN: rpi_gpio.IN }
|
|
self._pud_mapping = { PUD_OFF: rpi_gpio.PUD_OFF,
|
|
PUD_DOWN: rpi_gpio.PUD_DOWN,
|
|
PUD_UP: rpi_gpio.PUD_UP }
|
|
|
|
def setup(self, pin, mode, pull_up_down=PUD_OFF):
|
|
"""Set the input or output mode for a specified pin. Mode should be
|
|
either OUTPUT or INPUT.
|
|
"""
|
|
self.rpi_gpio.setup(pin, self._dir_mapping[mode],
|
|
pull_up_down=self._pud_mapping[pull_up_down])
|
|
|
|
def output(self, pin, value):
|
|
"""Set the specified pin the provided high/low value. Value should be
|
|
either HIGH/LOW or a boolean (true = high).
|
|
"""
|
|
self.rpi_gpio.output(pin, value)
|
|
|
|
def input(self, pin):
|
|
"""Read the specified pin and return HIGH/true if the pin is pulled high,
|
|
or LOW/false if pulled low.
|
|
"""
|
|
return self.rpi_gpio.input(pin)
|
|
|
|
def add_event_detect(self, pin, edge, callback=None, bouncetime=-1):
|
|
"""Enable edge detection events for a particular GPIO channel. Pin
|
|
should be type IN. Edge must be RISING, FALLING or BOTH. Callback is a
|
|
function for the event. Bouncetime is switch bounce timeout in ms for
|
|
callback
|
|
"""
|
|
kwargs = {}
|
|
if callback:
|
|
kwargs['callback']=callback
|
|
if bouncetime > 0:
|
|
kwargs['bouncetime']=bouncetime
|
|
self.rpi_gpio.add_event_detect(pin, edge, **kwargs)
|
|
|
|
def remove_event_detect(self, pin):
|
|
"""Remove edge detection for a particular GPIO channel. Pin should be
|
|
type IN.
|
|
"""
|
|
self.rpi_gpio.remove_event_detect(pin)
|
|
|
|
def add_event_callback(self, pin, callback):
|
|
"""Add a callback for an event already defined using add_event_detect().
|
|
Pin should be type IN.
|
|
"""
|
|
self.rpi_gpio.add_event_callback(pin, callback)
|
|
|
|
def event_detected(self, pin):
|
|
"""Returns True if an edge has occured on a given GPIO. You need to
|
|
enable edge detection using add_event_detect() first. Pin should be
|
|
type IN.
|
|
"""
|
|
return self.rpi_gpio.event_detected(pin, callback)
|
|
|
|
def wait_for_edge(self, pin, edge):
|
|
"""Wait for an edge. Pin should be type IN. Edge must be RISING,
|
|
FALLING or BOTH.
|
|
"""
|
|
self.rpi_gpio.wait_for_edge(pin, edge)
|
|
|
|
class AdafruitBBIOAdapter(BaseGPIO):
|
|
"""GPIO implementation for the Beaglebone Black using the Adafruit_BBIO
|
|
library.
|
|
"""
|
|
|
|
def __init__(self, bbio_gpio):
|
|
self.bbio_gpio = bbio_gpio
|
|
# Define mapping of Adafruit GPIO library constants to RPi.GPIO constants.
|
|
self._dir_mapping = { OUT: bbio_gpio.OUT,
|
|
IN: bbio_gpio.IN }
|
|
self._pud_mapping = { PUD_OFF: bbio_gpio.PUD_OFF,
|
|
PUD_DOWN: bbio_gpio.PUD_DOWN,
|
|
PUD_UP: bbio_gpio.PUD_UP }
|
|
|
|
def setup(self, pin, mode, pull_up_down=PUD_OFF):
|
|
"""Set the input or output mode for a specified pin. Mode should be
|
|
either OUTPUT or INPUT.
|
|
"""
|
|
self.bbio_gpio.setup(pin, self._dir_mapping[mode],
|
|
pull_up_down=self._pud_mapping[pull_up_down])
|
|
|
|
def output(self, pin, value):
|
|
"""Set the specified pin the provided high/low value. Value should be
|
|
either HIGH/LOW or a boolean (true = high).
|
|
"""
|
|
self.bbio_gpio.output(pin, value)
|
|
|
|
def input(self, pin):
|
|
"""Read the specified pin and return HIGH/true if the pin is pulled high,
|
|
or LOW/false if pulled low.
|
|
"""
|
|
return self.bbio_gpio.input(pin)
|
|
|
|
def add_event_detect(self, pin, edge, callback=None, bouncetime=-1):
|
|
"""Enable edge detection events for a particular GPIO channel. Pin
|
|
should be type IN. Edge must be RISING, FALLING or BOTH. Callback is a
|
|
function for the event. Bouncetime is switch bounce timeout in ms for
|
|
callback
|
|
"""
|
|
kwargs = {}
|
|
if callback:
|
|
kwargs['callback']=callback
|
|
if bouncetime > 0:
|
|
kwargs['bouncetime']=bouncetime
|
|
self.bbio_gpio.add_event_detect(pin, edge, **kwargs)
|
|
|
|
def remove_event_detect(self, pin):
|
|
"""Remove edge detection for a particular GPIO channel. Pin should be
|
|
type IN.
|
|
"""
|
|
self.bbio_gpio.remove_event_detect(pin)
|
|
|
|
def add_event_callback(self, pin, callback, bouncetime=-1):
|
|
"""Add a callback for an event already defined using add_event_detect().
|
|
Pin should be type IN. Bouncetime is switch bounce timeout in ms for
|
|
callback
|
|
"""
|
|
kwargs = {}
|
|
if bouncetime > 0:
|
|
kwargs['bouncetime']=bouncetime
|
|
self.bbio_gpio.add_event_callback(pin, callback, **kwargs)
|
|
|
|
def event_detected(self, pin):
|
|
"""Returns True if an edge has occured on a given GPIO. You need to
|
|
enable edge detection using add_event_detect() first. Pin should be
|
|
type IN.
|
|
"""
|
|
return self.bbio_gpio.event_detected(pin, callback)
|
|
|
|
def wait_for_edge(self, pin, edge):
|
|
"""Wait for an edge. Pin should be type IN. Edge must be RISING,
|
|
FALLING or BOTH.
|
|
"""
|
|
self.bbio_gpio.wait_for_edge(pin, edge)
|
|
|
|
def get_platform_gpio(**keywords):
|
|
"""Attempt to return a GPIO instance for the platform which the code is being
|
|
executed on. Currently supports only the Raspberry Pi using the RPi.GPIO
|
|
library and Beaglebone Black using the Adafruit_BBIO library. Will throw an
|
|
exception if a GPIO instance can't be created for the current platform. The
|
|
returned GPIO object is an instance of BaseGPIO.
|
|
"""
|
|
plat = Platform.platform_detect()
|
|
if plat == Platform.RASPBERRY_PI:
|
|
import RPi.GPIO
|
|
return RPiGPIOAdapter(RPi.GPIO, **keywords)
|
|
elif plat == Platform.BEAGLEBONE_BLACK:
|
|
import Adafruit_BBIO.GPIO
|
|
return AdafruitBBIOAdapter(Adafruit_BBIO.GPIO, **keywords)
|
|
elif plat == Platform.UNKNOWN:
|
|
raise RuntimeError('Could not determine platform.')
|