The FT232H's MPSSE is great for generating signals to communicate using the SPI protocol.  The MPSSE can take care of generating a clock signal from about 450hz to 30Mhz, and read & write bytes of data at that frequency.  The Python GPIO library that was installed includes a small wrapper around MPSSE functions to simplify the use of reading and writing SPI data.

When using SPI with the FT232H the following pins will have a special meaning:

  • D0 - SCK / Clock signal.  This will be the clock that tells devices when to sample and write data.
  • D1 - MOSI / Data Out.  This will output data from the FT232H to the connected device.
  • D2 - MISO / Data In.  This will read data from the connected device to the FT232H.

One thing to note is that there isn't an explicit chip select / enable pin.  You should use any of the free GPIO pins as a dedicated chip select pin and specify that pin when creating the SPI object.

To use SPI with the Python library you need to create an instance of the Adafruit_GPIO.FT232H.SPI class.  For example see the following code:

Download: file
import Adafruit_GPIO.FT232H as FT232H

# Temporarily disable FTDI serial drivers.
FT232H.use_FT232H()

# Find the first FT232H device.
ft232h = FT232H.FT232H()

# Create a SPI interface from the FT232H using pin 8 (C0) as chip select.
# Use a clock speed of 3mhz, SPI mode 0, and most significant bit first.
spi = FT232H.SPI(ft232h, cs=8, max_speed_hz=3000000, mode=0, bitorder=FT232H.MSBFIRST)

# Write three bytes (0x01, 0x02, 0x03) out using the SPI protocol.
spi.write([0x01, 0x02, 0x03])

Notice that the code starts by importing the FT232H part of the GPIO library and disabling the FTDI serial drivers as your saw in the GPIO example.

Next the code creates a FT232H object also like was done in the GPIO example.

The next line of code creates a FT232H.SPI object using the FT232H device that was just created.  An optional chip select/slave select line is specified using GPIO 8 / pin C0 with the cs parameter value.  

Notice too the speed, mode, and bit order of the SPI protocol are specified as parameters of the initializer.  Mode 0 and bit order of MSBFIRST are actually the default values and do not necessarily need to be specified here, but it's helpful to show them for clarity.

Possible mode values are 0 through 3 and they correspond to SPI mode values for AVR processors.

Bitorder can be either MSBFIRST for most significant bits to be clocked out first, or LSBFIRST for the least significant bits to be clocked out first.

Finally the last line shows how to send 3 bytes of data out the D1 (MOSI) line using the write() function.  The D0 (SCK) line will generate a clock signal, and the D1 (MOSI) line will clock out bits of data with every clock pulse.

There are also SPI functions you can use to read and transfer (read and write at the same time) data:

Download: file
# Read 3 bytes of data using the SPI protocol.
response = spi.read(3)
print 'Received {0}'.format(response)

# Write 3 bytes and simultaneously read 3 bytes using the SPI protocl.
response = spi.transfer([0x01, 0x02, 0x03])
print 'Received {0}'.format(response)

The read() function will read the specified number of bytes on the D2 (MISO) line (sending clock pulses out D0 (SCK) as necessary).

The transfer() function is like calling write() and read() at the same time.  The specified array of bytes will be sent out D1 (MOSI) while at the same time data will be read from D2 (MISO).

That's all there is to using the SPI protocol with the FT232H and the Adafruit Python GPIO library!

You might also be interested in this tutorial which shows how to use the FT232H breakout with some Adafruit SPI  devices that have been ported to use Adafruit's Python GPIO library.

Driving NeoPixels With SPI

One interesting use of the SPI protocol is driving the colors of WS2811/WS2812 NeoPixel addressable RGB LEDs.  These LEDs don't actually use SPI to communicate, instead they have a very specific self-clocked signal for sending pixel color bits.  However by using a high speed 6Mhz SPI signal we can 'oversample' the NeoPixel control signal and generate a close approximation of it from the D1 (MOSI) line of the FT232H.

Note that this method of driving NeoPixels is limited to lighting about 340 pixels at a time.  This limitation comes from the maximum amount of data that can be sent to the FT232H at one time over the USB bus, about 64 kilobytes of data.  Because we're oversampling the NeoPixel control signal each pixel actually takes 24*8 bytes of SPI data (or one byte of SPI data for every bit of pixel data).

To demonstrate lighting NeoPixels with the FT232H breakout you'll need the following parts:

  • Assembled FT232H breakout board.
  • NeoPixel strip, strand, matrix, etc.
    • Remember at most you can only light about 340 pixels.
  • Strong 5 volt power supply to drive the NeoPixels.  
    • Each pixel can take up to 60mA, so driving more than a handful of pixels can quickly add up to a few amps or more of current. Do not try to power more than a couple NeoPixels over the FT232H 5V line!
  • Level converter chip to convert 3.3 to 5 volts OR a power diode that can handle the full power of all the NeoPixels.
    • The NeoPixel control signal needs to be at least 0.7*Vcc (power supply voltage) which is just a little too high for the 3.3 volt output of the FT232H breakout.  Just like lighting NeoPixels with the Raspberry Pi you need to either convert the control signal to 5 volts using a chip like the 74AHCT125, or drop the NeoPixel power supply down slightly below 5 volts using a power diode.
  • Jumper wires and breadboard.

In this example I'm lighting a 16 pixel ring so I'll use a power diode that can handle 1 amp of current.  If you're using more than 16 NeoPixels you'll want a larger power diode, or a level converter chip.

Connect the hardware as follows:

  • FT232H GND to power supply ground.
  • FT232H D1 (MOSI) to NeoPixel signal input.
  • Power supply positive voltage to diode anode (side without the stripe).
  • NeoPixel positive voltage to diode cathode (side with the stripe).
  • NeoPixel ground to power supply ground.

A picture of the hardware setup is below (note I've added a large capacitor to the power supply as recommended in the NeoPixel Uberguide):

Now create a file neopixels.py and fill it with the following code:

Download: file
import time

import Adafruit_GPIO as GPIO
import Adafruit_GPIO.FT232H as FT232H


class NeoPixel_FT232H(object):
	def __init__(self, n):
		# Create an FT232H object.
		self.ft232h = FT232H.FT232H()
		# Create a SPI interface for the FT232H object.  Set the SPI bus to 6mhz.
		self.spi    = FT232H.SPI(self.ft232h, max_speed_hz=6000000)
		# Create a pixel data buffer and lookup table.
		self.buffer = bytearray(n*24)
		self.lookup = self.build_byte_lookup()

	def build_byte_lookup(self):
		# Create a lookup table to map all byte values to 8 byte values which
		# represent the 6mhz SPI data to generate the NeoPixel signal for the
		# specified byte.
		lookup = {}
		for i in range(256):
			value = bytearray()
			for j in range(7, -1, -1):
				if ((i >> j) & 1) == 0:
					value.append(0b11100000)
				else:
					value.append(0b11111000)
			lookup[i] = value
		return lookup

	def set_pixel_color(self, n, r, g, b):
		# Set the pixel RGB color for the pixel at position n.
		# Assumes GRB NeoPixel color ordering, but it's easy to change below.
		index = n*24
		self.buffer[index   :index+8 ] = self.lookup[int(g)]
		self.buffer[index+8 :index+16] = self.lookup[int(r)]
		self.buffer[index+16:index+24] = self.lookup[int(b)]

	def show(self):
		# Send the pixel buffer out the SPI data output pin (D1) as a NeoPixel
		# signal.
		self.spi.write(self.buffer)


# Run this code when the script is called at the command line:
if __name__ == '__main__':
	# Define the number of pixels in the NeoPixel strip.
	# Only up to ~340 pixels can be written using the FT232H.
	pixel_count = 16
	# Create a NeoPixel_FT232H object.
	pixels = NeoPixel_FT232H(pixel_count)
	# Animate each pixel turning red.
	# Loop through each pixel.
	for i in range(pixel_count):
		# Set the pixel color to pure red.
		pixels.set_pixel_color(i, 255, 0, 0)
		# Show the pixel buffer by sending it to the LEDs.
		pixels.show()
		# Delay for a short period of time.
		time.sleep(0.25)
	# Animate each pixel turning pure green.
	for i in range(pixel_count):
		pixels.set_pixel_color(i, 0, 255, 0)
		pixels.show()
		time.sleep(0.25)
	# Animate each pixel turning pure blue.
	for i in range(pixel_count):
		pixels.set_pixel_color(i, 0, 0, 255)
		pixels.show()
		time.sleep(0.25)
	# Animate a pattern of colors marching around the pixels.
	# Create a pattern of colors to display.
	colors = [ (255, 0, 0), (255, 255, 0), (0, 255, 0), (0, 255, 255), 
				(0, 0, 255), (255, 0, 255) ]
	offset = 0
	print 'Press Ctrl-C to quit.'
	while True:
		# Loop through all the pixels and set their color based on the pattern.
		for i in range(pixel_count):
			color = colors[(i+offset)%len(colors)]
			pixels.set_pixel_color(i, color[0], color[1], color[2])
		pixels.show()
		# Increase the offset to make the colors change position.
		offset += 1
		time.sleep(0.25)

Save the file and navigate to the folder with it in a terminal, then execute the following in Windows to run the program:

Download: file
python neopixels.py

Or on Mac OSX or Linux  execute the following to run the program as root:

Download: file
sudo python neopixels.py

You should see the NeoPixels light up and animate with different colors.  Note that you might need to change the pixel_count variable in the main part of the program to match the number of pixels in your NeoPixel strip, circle, matrix, etc.

This code does a couple things at a high level.  It first defines a class called NeoPixel_FT232H.  This class contains some methods and state which control generating the NeoPixel signal with an FT232H board.  The second part of the code uses the NeoPixel_FT232H class to animate the NeoPixels.

You actually don't need to fully understand the NeoPixel_FT232H class code to use it.  This code performs the 'oversampling' by using a lookup table to expand each byte of color data into 8 bytes of SPI data that approximates the NeoPixel control signal.  The only important thing to know about the NeoPixel_FT232H class is that it exposes a set_pixel_color() function which allows you to set the red, green, and blue color value of a pixel.

Instead let's walk through a bit of the second half of the code that uses the NeoPixel_FT232H class:

Download: file
# Run this code when the script is called at the command line:
if __name__ == '__main__':
	# Define the number of pixels in the NeoPixel strip.
	# Only up to ~340 pixels can be written using the FT232H.
	pixel_count = 16
	# Create a NeoPixel_FT232H object.
	pixels = NeoPixel_FT232H(pixel_count)

This portion of code has an if statement that checks if the program is being run from the command line before executing.  This is just a standard Python idiom for defining the main entry point of a program.

Inside the if block you can see the number of pixels is defined and set in the pixel_count variable.  Then the NeoPixel_FT232H object is created by telling it that number of pixels as its only parameter.

Download: file
	# Animate each pixel turning red.
	# Loop through each pixel.
	for i in range(pixel_count):
		# Set the pixel color to pure red.
		pixels.set_pixel_color(i, 255, 0, 0)
		# Show the pixel buffer by sending it to the LEDs.
		pixels.show()
		# Delay for a short period of time.
		time.sleep(0.25)
	# Animate each pixel turning pure green.
	for i in range(pixel_count):
		pixels.set_pixel_color(i, 0, 255, 0)
		pixels.show()
		time.sleep(0.25)
	# Animate each pixel turning pure blue.
	for i in range(pixel_count):
		pixels.set_pixel_color(i, 0, 0, 255)
		pixels.show()
		time.sleep(0.25)

The next section performs a few simple animations that turn each pixel on with primary colors.  You can see a loop is used to go through each pixel and the set_pixel_color() function is called to the pixel color.  This function takes 4 parameters, the first is the number of the pixel (start at 0), and the last 3 parameters are the red, green, and blue color components.  Each component should be a value from 0 to 255, where 0 is no color and 255 is maximum color intensity.

After changing the pixel color, the show() function is called to send the colors to the LEDs.  You must call show() in order to make the NeoPixels light up with the colors you've set previously!

Finally notice the time.sleep() function is used to delay for a short period of time (a quarter of a second in this case).  This sleep function is very useful for animating color changes that should go somewhat slowly.

Download: file
	# Animate a pattern of colors marching around the pixels.
	# Create a pattern of colors to display.
	colors = [ (255, 0, 0), (255, 255, 0), (0, 255, 0), (0, 255, 255), 
				(0, 0, 255), (255, 0, 255) ]
	offset = 0
	print 'Press Ctrl-C to quit.'
	while True:
		# Loop through all the pixels and set their color based on the pattern.
		for i in range(pixel_count):
			color = colors[(i+offset)%len(colors)]
			pixels.set_pixel_color(i, color[0], color[1], color[2])
		pixels.show()
		# Increase the offset to make the colors change position.
		offset += 1
		time.sleep(0.25)

Finally the code enters an infinite loop where it animates a rainbow of colors marching across the pixels.  This code uses the same set_pixel_color() function, but has a little extra logic to pick a color from a list and increase the offset of chosen colors every loop iteration.  Also notice the show() function is again called after updating pixel colors in order to make the LEDs light up with the desired colors.

That's all there is to controlling NeoPixels with SPI from the FT232H breakout!  Feel free to use the code above in your own NeoPixel projects!

This guide was first published on Nov 12, 2014. It was last updated on Nov 12, 2014. This page (SPI) was last updated on Jul 15, 2019.