RASP-FT232H-MPSSE-Usage-SPI

FT232 en mode Bus SPI

Le FT232H en mode MPSSE est génial pour générer des signaux pour communiquer en utilisant le protocol SPI. Le MPSSE est capable de générer un signal d'horloge de 450hz (environ) à 30Mhz, et de lire et écrire des octets de données à cette fréquence. La bibliothèque Python GPIO qui a été installé inclus un "wrapper" autour de certaines fonctions MPSSE pour simplifier la lecture et l'écriture de donnée SPI.

En utilisant SPI avec le FT232H, les broches suivantes ont une signification spéciale:

• D0 - SCK / Clock signal / Signal d'horloge : C'est le signal d'horloge qui indique aux périphériques quand échantilloner et écrire des données.
• D1 - MOSI / Data Out / Sortie de donnée : ligne de sortie de donnée du FT232H vers le périphérique.
• D2 - MISO / Data In / Entrée de donnée : ligne pour lire les données en provenance du périphérique connecté sur le FT232H.

Une chose à noter, c'est qu'il n'existe pas de broche chip select / enable explicite. Vous devriez utiliser une des broches GPIO libre comme signal chip select dédicacé. Vous devrez préciser cette broche lors de la création de l'objet SPI.

Vous aurez besoin de créer une instance de la classe Adafruit_GPIO.FT232H.SPI pour utiliser le bus SPI du FT232H sous Python:

import Adafruit_GPIO.FT232H as FT232H

# Désactiver temporairement le pilote FTDI série.
FT232H.use_FT232H()

# Trouver le premier périphérique FT232H.
ft232h = FT232H.FT232H()

# Créer une interface SPI du FT232H en utilisant la broche 8 (C0) comme signal ''chip select''.
# Utiliser une fréquence d'horloge de 3mhz, mode SPI 0 et le bit le plus significatif en premier.
spi = FT232H.SPI(ft232h, cs=8, max_speed_hz=3000000, mode=0, bitorder=FT232H.MSBFIRST)

# Ecrire 3 octets/bytes (0x01, 0x02, 0x03) en utilisant le protocole SPI.
spi.write([0x01, 0x02, 0x03])

Notez que le code commence par importer les éléments FT232H de la bibliothèque GPIO -puis- désactive le pilote FTDI série (comme dans l'exemple GPIO).

Ensuite, le code crée un objet FT232H (comme dans l'exemple GPIO).

La ligne suivante crée une instance de la classe FT232H.SPI qui utilise le périphérique FT232H (l'instance créée juste avant). Un signal chip select/slave select optionnel est défini et assigné au GPIO 8 / broche C0 à l'aide du paramètre "cs" .

Notez également la vitesse (speed), le mode et l'ordre d'envoi des bit (bitorder) du protocol SPI qui sont spécifiés en paramètre lors de l'initialisation. Un mode 0 et un bitorder égal à MSBFIRST sont les valeurs par défaut et ne doivent pas nécessairement être spécifiés (mais il est toujours utile de les indiquer explicitement.

Les autres valeurs possible vont de 0 à 3 et correspondent au valeurs du mode SPI pour les processeurs AVR (wikipedia, anglais).

L'ordre des bits Bitorder peut soit être MSBFIRST (pour envoyer le bit le plus significatif en premier) ou LSBFIRST (pour envoyer le bit le moins significatif d'abord).

Pour finir, la dernière ligne montre comment envoyer 3 octets (3 bytes) sur la ligne D1 (MOSI) en utilisant la fonction write(). La ligne D0 (SCK) générera le signal d'horloge tandis que la ligne D1 (MOSI) émettra les bits (un par un) pour chaque impulsion d'horloge.

Il y a également des fonctions SPI que vous pouvez utiliser pour lire et transférer des données (lire et écrire en même temps):

# Lecture de 3 octets de données en utilisant le protocole SPI.
response = spi.read(3)
print 'Received {0}'.format(response)

# Ecrire 3 octets/bytes et lire simultanément 3 octets/bytes en utilisant le protocole SPI.
response = spi.transfer([0x01, 0x02, 0x03])
print 'Received {0}'.format(response)

La fonction read() lira un nombre prédéfini d'octets/bytes sur la ligne D2 (MISO) (et envoi du signal d'horloge approprié sur D0 (SCK)).

La fonction transfer() revient à un appel des fonctions write() et read() en même temps. Le tableau de d'octets (bytes) sera envoyé sur la ligne D1 (MOSI) tandis que -durant ce même temps- les données seront lues sur la ligne D2 (MISO).

Voila, c'est tout ce que nous avons besoin de savoir pour communiquer avec le protocole/bus SPI du FT232H à l'aide de la bibliothèque Adafruit Python GPIO!

Vous pourriez également être intéressé par la partie de ce tutoriel qui explique comment utiliser le breakout FT232H avec quelques périphériques SPI d'Adafruit (et comment réaliser un portage en utilisant la bibliothèque Adafruit Python GPIO).

Contrôler des NeoPixels avec SPI

Un des intérêt d'utiliser le protocole SPI est qu'il permet de contrôler des LEDs Neopixels (Leds digitales RGB adressable à base de WS2811/WS2812). Ces LEDs n'utilisent pas le bus SPI pour communiquer. A la place, ces LEDs utilisent un signal très spécifique réclament une grande maîtrise des temps d'émission pour envoyer les informations de couleur (les différents bits) des différents LEDs du ruban. Cependant, en utilisant un signal SPI à haute vitesse (6Mhz) il est possible de 'sur-échantillonner' le signal de contrôle NeoPixel et de générer une approximation suffisamment proche sur la ligne D1 (MOSI) du FT232H.

La limitation du nombre de pixel contrôlable est fixé par la quantité maximale d'information qui peut être envoyer en une fois sur le FT232H via le bus USB. Cette limite est d'environ 64 kilobytes (Kilo Octets). Etant donné que nous faisons du sur-échantillonnage du signal de contrôle NéoPixel, chaque pixel requière 24*8 octets/bytes de donnée SPI (ou un octet/byte de donnée SPI pour chaque bit de donnée NéoPixel).

Vous aurez besoin des éléments suivants pour tester l'utilisation de NeoPixel avec le breakout FT232H:

• Un breakout FT232H assemblé.
• Des NeoPixel (ruban, matrice, anneau, etc).
  Rappelez vous que vous ne pouvez contrôler qu'environ 340 pixels.
• Une alimentation 5 volts de qualité (bien régulée et capable de fournir le courant demandé).
  • Chaque LED consomme jusqu'à 60mA (100% blanc). Cela représente vite plusieurs ampères (ou plus) si vous accumulez des Pixels. N'essayer pas d'alimenter plus de quelques pixels sur la lignes 5V du FT232H !
• Une puce convertisseur de niveau logique pour convertir le signal 3.3V vers 5 volts -OU- Une diode de puissance capable de supporter le total du courant d'alimentation des pixels.
  • Le signal de contrôle NeoPixel à besoin d'atteindre au moins 0.7*Vcc (tension d'alimentation), ce qui est juste un peu supérieur au signal de sortie 3.3V (fourni par le breakout FT232H). Exactement comme dans ce tutoriel lighting NeoPixels with the Raspberry Pi (Adafruit, Anglais) ou l'on converti le signal de 3.3V en 5V à l'aide d'un 74AHCT125. L'autre option est de faire chuter la tension d'alimentation des néopixel en dessous de 5V en utilisant une diode de puissance de sorte que le signal de commande 3.3v soit suffisant.
• Des fils de connexion et breadboard.

Dans cet exemple, nous allons éclairer un anneau NéoPixe à 16 LEDs et nous allons utiliser une diode de puissance capable de gérer un courant de 1 ampère. Si vous utilisez plus de 16 pixels, il faudra envisager une diode plus puissance (ou un convertisseur de niveau logique 74AHCT125 ).

Connectez le matériel comme suit:

• 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):

Crédit: AdaFruit Industries www.adafruit.com

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

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:

python neopixels.py

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

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:

# 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.

	# 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.

	# 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!

---

Source: Adafruit FT232H Breakout Add a serial protocol 'swiss army knife' to your computer and talk directly to devices with SPI, I2C, serial UART, GPIO's, and more!
Créé par Toni DiCola pour AdaFruit Industries.

Traduction réalisée par Meurisse D pour MCHobby.be.

Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : «  Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.

L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.

Traduit avec l'autorisation d'AdaFruit Industries - Translated with the permission from Adafruit Industries - www.adafruit.com