Refactor I2C and SPI to support FT232H as I2C and SPI master. No changes to existing I2C and SPI interface.

tdicola · tdicola · commit f04bedef05df · 2014-11-20T20:54:45.000-08:00
diff --git a/Adafruit_GPIO/FT232H.py b/Adafruit_GPIO/FT232H.py
@@ -94,7 +94,13 @@ def use_FT232H():
 	atexit.register(enable_FTDI_driver)
 
 
-class FT232H(object):
+class FT232H(GPIO.BaseGPIO):
+	# Make GPIO constants that match main GPIO class for compatibility.
+	HIGH = GPIO.HIGH
+	LOW  = GPIO.LOW
+	IN   = GPIO.IN
+	OUT  = GPIO.OUT
+
 	def __init__(self, vid=FT232H_VID, pid=FT232H_PID):
 		"""Create a FT232H object.  Will search for the first available FT232H
 		device with the specified USB vendor ID and product ID (defaults to
@@ -268,6 +274,13 @@ def mpsse_write_gpio(self):
 		"""Write the current MPSSE GPIO state to the FT232H chip."""
 		self._write(self.mpsse_gpio())
 
+	def get_i2c_device(self, address, **kwargs):
+		"""Return an I2CDevice instance using this FT232H object and the provided
+		I2C address.  Meant to be passed as the i2c_provider parameter to objects
+		which use the Adafruit_Python_GPIO library for I2C.
+		"""
+		return I2CDevice(self, address, **kwargs)
+
 	# GPIO functions below:
 
 	def _setup_pin(self, pin, mode):
@@ -336,12 +349,26 @@ def input(self, pin):
 
 
 class SPI(object):
-	def __init__(self, ft232h, clock_hz, mode=0, bitorder=MSBFIRST):
+	def __init__(self, ft232h, cs=None, max_speed_hz=1000000, mode=0, bitorder=MSBFIRST):
 		self._ft232h = ft232h
-		self.set_clock_hz(clock_hz)
+		# Initialize chip select pin if provided to output high.
+		if cs is not None:
+			ft232h.setup(cs, GPIO.OUT)
+			ft232h.set_high(cs)
+		self._cs = cs
+		# Initialize clock, mode, and bit order.
+		self.set_clock_hz(max_speed_hz)
 		self.set_mode(mode)
 		self.set_bit_order(bitorder)
 
+	def _assert_cs(self):
+		if self._cs is not None:
+			self._ft232h.set_low(self._cs)
+
+	def _deassert_cs(self):
+		if self._cs is not None:
+			self._ft232h.set_high(self._cs)
+
 	def set_clock_hz(self, hz):
 		"""Set the speed of the SPI clock in hertz.  Note that not all speeds
 		are supported and a lower speed might be chosen by the hardware.
@@ -407,10 +434,12 @@ def write(self, data):
 		length = len(data)-1
 		len_low  = length & 0xFF
 		len_high = (length >> 8) & 0xFF
+		self._assert_cs()
 		# Send command and length.
 		self._ft232h._write(str(bytearray((command, len_low, len_high))))
 		# Send data.
 		self._ft232h._write(str(bytearray(data)))
+		self._deassert_cs()
 
 	def read(self, length):
 		"""Half-duplex SPI read.  The specified length of bytes will be clocked
@@ -424,8 +453,10 @@ def read(self, length):
 		# considers 0 a length of 1 and FFFF a length of 65536
 		len_low  = (length-1) & 0xFF
 		len_high = ((length-1) >> 8) & 0xFF
+		self._assert_cs()
 		# Send command and length.
-		self._ft232h._write(str(bytearray(command, len_low, len_high, 0x87)))
+		self._ft232h._write(str(bytearray((command, len_low, len_high, 0x87))))
+		self._deassert_cs()
 		# Read response bytes.
 		return bytearray(self._ft232h._poll_read(length))
 
@@ -444,9 +475,11 @@ def transfer(self, data):
 		len_low  = (length-1) & 0xFF
 		len_high = ((length-1) >> 8) & 0xFF
 		# Send command and length.
+		self._assert_cs()
 		self._ft232h._write(str(bytearray((command, len_low, len_high))))
 		self._ft232h._write(str(bytearray(data)))
 		self._ft232h._write('\x87')
+		self._deassert_cs()
 		# Read response bytes.
 		return bytearray(self._ft232h._poll_read(length))
 
diff --git a/Adafruit_GPIO/I2C.py b/Adafruit_GPIO/I2C.py
@@ -56,6 +56,13 @@ def get_default_bus():
 	else:
 		raise RuntimeError('Could not determine default I2C bus for platform.')
 
+def get_i2c_device(address, busnum=get_default_bus(), **kwargs):
+	"""Return an I2C device for the specified address and on the specified bus.
+	If busnum isn't specified, the default I2C bus for the platform will attempt
+	to be detected.
+	"""
+	return Device(address, busnum, **kwargs)
+
 
 class Device(object):
 	"""Class for communicating with an I2C device using the smbus library.
diff --git a/Adafruit_GPIO/MCP230xx.py b/Adafruit_GPIO/MCP230xx.py
@@ -30,11 +30,15 @@ class MCP230xxBase(GPIO.BaseGPIO):
 	class for interacting with device.
 	"""
 
-	def __init__(self, address, busnum=I2C.get_default_bus()):
+	def __init__(self, address, i2c=None):
 		"""Initialize MCP230xx at specified I2C address and bus number.  If bus
 		is not specified it will default to the appropriate platform detected bus.
 		"""
-		self._i2c = I2C.Device(address, busnum)
+		# Create I2C device.
+		if i2c is None:
+			import Adafruit_GPIO.I2C as I2C
+			i2c = I2C
+		self._device = i2c.get_i2c_device(address, **kwargs)
 		# Assume starting in ICON.BANK = 0 mode (sequential access).
 		# Compute how many bytes are needed to store count of GPIO.
 		self.gpio_bytes = int(math.ceil(self.NUM_GPIO/8.0))
@@ -98,7 +102,7 @@ def input(self, pin):
 		"""
 		self._validate_pin(pin)
 		# Get GPIO state.
-		gpio = self._i2c.readList(self.GPIO, self.gpio_bytes)
+		gpio = self._device.readList(self.GPIO, self.gpio_bytes)
 		# Return True if pin's bit is set.
 		return (gpio[int(pin/8)] & 1 << (int(pin%8))) > 0
 
@@ -119,23 +123,23 @@ def write_gpio(self, gpio=None):
 		"""
 		if gpio is not None:
 			self.gpio = gpio
-		self._i2c.writeList(self.GPIO, self.gpio)
+		self._device.writeList(self.GPIO, self.gpio)
 
 	def write_iodir(self, iodir=None):
 		"""Write the specified byte value to the IODIR registor.  If no value
 		specified the current buffered value will be written.
 		"""
 		if iodir is not None:
 			self.iodir = iodir 
-		self._i2c.writeList(self.IODIR, self.iodir)
+		self._device.writeList(self.IODIR, self.iodir)
 
 	def write_gppu(self, gppu=None):
 		"""Write the specified byte value to the GPPU registor.  If no value
 		specified the current buffered value will be written.
 		"""
 		if gppu is not None:
 			self.gppu = gppu
-		self._i2c.writeList(self.GPPU, self.gppu)
+		self._device.writeList(self.GPPU, self.gppu)
 
 
 class MCP23017(MCP230xxBase):
diff --git a/Adafruit_GPIO/SPI.py b/Adafruit_GPIO/SPI.py
@@ -22,8 +22,6 @@
 import operator
 import time
 
-import spidev
-
 import Adafruit_GPIO as GPIO
 
 
@@ -39,6 +37,7 @@ def __init__(self, port, device, max_speed_hz=500000):
 		identify the device, for example the device /dev/spidev1.0 would be port
 		1 and device 0.
 		"""
+		import spidev
 		self._device = spidev.SpiDev()
 		self._device.open(port, device)
 		self._device.max_speed_hz=max_speed_hz
diff --git a/setup.py b/setup.py
@@ -11,7 +11,7 @@
 	requires.append('spidev')
 
 setup(name              = 'Adafruit_GPIO',
-      version           = '0.6.1',
+      version           = '0.6.5',
       author            = 'Tony DiCola',
       author_email      = 'tdicola@adafruit.com',
       description       = 'Library to provide a cross-platform GPIO interface on the Raspberry Pi and Beaglebone Black using the RPi.GPIO and Adafruit_BBIO libraries.',
