RASP-FT232H-MPSSE-Usage-SPI - Historique des versions

Admin le 19 mars 2017 à 15:15

2017-03-19T15:15:21Z

Admin : /* Programmation */

2017-03-19T15:15:06Z

Programmation

Admin : /* Programmation */

2017-03-19T15:07:11Z

Programmation

Admin : /* Contrôler des NeoPixels avec SPI */

2017-03-19T13:42:16Z

Contrôler des NeoPixels avec SPI

Voir les modifications

Admin : /* Contrôler des NeoPixels avec SPI */

2017-03-19T12:50:48Z

Contrôler des NeoPixels avec SPI

Admin : /* Contrôler des NeoPixels avec SPI */

2017-03-19T12:45:04Z

Contrôler des NeoPixels avec SPI

Admin : /* FT232 en mode Bus SPI */

2017-03-19T11:56:54Z

FT232 en mode Bus SPI

Admin le 19 mars 2017 à 11:56

2017-03-19T11:56:27Z

Admin : /* FT232 en mode Bus SPI */

2017-03-18T21:20:33Z

FT232 en mode Bus SPI

Admin : /* FT232 en mode SPI */

2017-03-18T16:20:23Z

FT232 en mode SPI

← Version précédente		Version du 19 mars 2017 à 15:15
Ligne 1 :		Ligne 1 :
	{{RASP-FT232H-NAV}}		{{RASP-FT232H-NAV}}
−
−	~~{{traduction}}~~

	== FT232 en mode Bus SPI ==		== FT232 en mode Bus SPI ==

@@ Ligne 205 : / Ligne 205 : @@
 sudo python neopixels.py
 </syntaxhighlight>
 Vous devriez voir les NeoPixels s'allumer et s'animer avec différentes couleurs.
@@ Ligne 288 : / Ligne 286 : @@
 </syntaxhighlight>
-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.
+Pour finir, le code entre dans une boucle infinie qui anime un arc en clien progressant le long des pixels. Ce code utilise également la fonction '''set_pixel_color()''' mais avec une logique un peu plus élaborée qui sélectionne une couleur dans une liste de couleurs prédéfinies à chaque itération de la boucle.
-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!
+Voila, c'est tout ce qu'il est nécessaire de savoir pour contrôler des NéoPixels depuis le bus SPI du breakout FT232H!
 {{RASP-FT232H-TRAILER}}

@@ Ligne 208 : / Ligne 208 : @@
 {{traduction}}
-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.
+Vous devriez voir les NeoPixels s'allumer et s'animer avec différentes couleurs.
-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.
+{{underline|note:}} vous pourriez avoir besoin de changer la valeur de la variable pixel_count dans la section "__main__" du programme pour que la valeur corresponde au nombre de pixels que vous avez dans votre montage.
-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.
+Ce code réalise plusieurs opérations de haut-niveau. Il commence par définir une classe nommée NeoPixel_FT232H. Cette classe contient les méthodes et les états nécessaires à la génération du signal NeoPixelavec la carte FT232H. La seconde partie du code utilise la classe NeoPixel_FT232H pour animer les NéoPixels.
-Instead let's walk through a bit of the second half of the code that uses the NeoPixel_FT232H class:
+Il n'est pas vraiment nécessaire de comprendre le code de la classe NeoPixel_FT232H pour pouvoir l'utiliser. Le code effectue un 'sur-échantillonnage' en utilisant une table de correspondance qui étend chaque octet/byte de couleur en enchaînement de 8 octets/bytes de donnée SPI (ce qui permet de faire une approximation du signal de contrôle NeoPixel). La seule chose vraiment importante à savoir à propos de de la classe NeoPixel_FT232H c'est qu'elle expose la méthode '''set_pixel_color()''' qui permet d'assigner la couleur (red,green,blue = rouge,vert,bleu) pour chaque pixel.
 <syntaxhighlight lang="python">
-# Run this code when the script is called at the command line:
+# Python exécute le code ci-dessous lorsque le script est appelé en ligne de commande:
 if __name__ == '__main__':
-	# Define the number of pixels in the NeoPixel strip.
+	# Défini le nombre de pixels utilisé dans le montage.
-	# Only up to ~340 pixels can be written using the FT232H.
+	# Capable de gérer jusqu'à environ 340 pixels via un FT232H.
 	pixel_count = 16
-	# Create a NeoPixel_FT232H object.
+	# Créer un objet NeoPixel_FT232H.
 	pixels = NeoPixel_FT232H(pixel_count)
 </syntaxhighlight>
-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.
+Cette portion de code contient une commande {{fname|if}} qui vérifie si le programme est lancé en ligne de commande (ou inclus dans un autre programme).
-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.
+C'est un idiom standard en python qui vérifie le mode de démarrage du script avant de l'exécuter.
 <syntaxhighlight lang="python">
-	# Animate each pixel turning red.
+	# Animation - allumer chaque pixel en rouge.
-	# Loop through each pixel.
+	# Passer chaque pixel en revue.
 	for i in range(pixel_count):
-		# Set the pixel color to pure red.
+		# Changer la couleur du pixel en rouge pure.
 		pixels.set_pixel_color(i, 255, 0, 0)
-		# Show the pixel buffer by sending it to the LEDs.
+		# Envoyer le buffer (de pixel) vers les LEDs.
 		pixels.show()
-		# Delay for a short period of time.
+		# faire une toute petite pause.
 		time.sleep(0.25)
-	# Animate each pixel turning pure green.
+	# Animation - allumer chaque pixel en vert pure.
 	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.
+	# Animation - allumer chaque pixel en bleu pure.
 	for i in range(pixel_count):
 		pixels.set_pixel_color(i, 0, 0, 255)
@@ Ligne 253 : / Ligne 256 : @@
 </syntaxhighlight>
-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.
+La section suivante réalise quelques animations simples. Elles allument chaque pixel dans une couleur primaire à l'aide de la fonction '''set_pixel_color()'''.
-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!
+Il est impératif d'appeler '''show()''' pour rafraîchir les données de couleur dans le ruban NéoPixel!
-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.
+Pour finir, notez que la fonction '''time.sleep()''' est utilisé pour créer un délai de 1/4 seconde. Cela permet de réaliser l'allumage progressif du ruban (sous forme d'animation).
 <syntaxhighlight lang="python">
-	# Animate a pattern of colors marching around the pixels.
+	# Un modèle (pattern) de couleur qui se déplace le long des pixels.
-	# Create a pattern of colors to display.
+	# Creation du modele de couleur.
 	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.'
+	print 'Presser Ctrl-C pour quitter.'
 	while True:
-		# Loop through all the pixels and set their color based on the pattern.
+		# Passer tous les pixels en revue et fixer leur couleur en fonction du modèle.
 		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.
+		# Incrementer le decalage (offset) pour changer la position des differentes couleurs.
 		offset += 1
 		time.sleep(0.25)

@@ Ligne 86 : / Ligne 86 : @@
 Connectez le matériel comme suit:
-* FT232H GND to power supply ground.
+* La masse/GND du FT232H --vers--> supply ground.
-* FT232H D1 (MOSI) to NeoPixel signal input.
+* FT232H D1 (MOSI) sur le signal d'entrée NeoPixel.
 * Power supply positive voltage to diode anode (side without the stripe).
 * NeoPixel positive voltage to diode cathode (side with the stripe).

@@ Ligne 68 : / Ligne 68 : @@
 == Contrôler des NeoPixels avec 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 [https://learn.adafruit.com/adafruit-neopixel-uberguide/advanced-coding#writing-your-own-library 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.
+Un des intérêt d'utiliser le protocole SPI est qu'il permet de contrôler des {{cl|487|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 [[NeoPixel-UserGuide|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.
-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).
+{{ambox-stop|text=Cette méthode de pilotage parmet de prendre le contrôle d'un nombre limité de pixels (environ 340 pixels).}}
-To demonstrate lighting NeoPixels with the FT232H breakout you'll need the following parts:
+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).
-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.
+Vous aurez besoin des éléments suivants pour tester l'utilisation de NeoPixel avec le breakout FT232H:
-Connect the hardware as follows:
+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 {{pl|1041|74AHCT125}} ).
 * FT232H GND to power supply ground.
 * FT232H D1 (MOSI) to NeoPixel signal input.

← Version précédente		Version du 19 mars 2017 à 11:56
Ligne 38 :		Ligne 38 :

	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" .		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" .
−
−	~~{{traduction}}~~

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

@@ Ligne 41 : / Ligne 41 : @@
 {{traduction}}
-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.
+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.
-Possible mode values are 0 through 3 and they correspond to [http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus#Mode_numbers SPI mode values for AVR processors] (''wikipedia, anglais'').
+Les autres valeurs possible vont de 0 à 3 et correspondent au [http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus#Mode_numbers valeurs du mode SPI pour les processeurs AVR] (''wikipedia, anglais'').
-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.
+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).
-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.
+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.
-There are also SPI functions you can use to read and transfer (read and write at the same time) data:
+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):
 <syntaxhighlight lang="python">
-# Read 3 bytes of data using the SPI protocol.
+# Lecture de 3 octets de données en utilisant le protocole SPI.
 response = spi.read(3)
 print 'Received {0}'.format(response)
-# Write 3 bytes and simultaneously read 3 bytes using the SPI protocl.
+# 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)
 </syntaxhighlight>
-The '''read()''' function will read the specified number of bytes on the '''D2 (MISO)''' line (sending clock pulses out '''D0 (SCK)''' as necessary).
+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)''').
-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)'''.
+La fonction '''transfer()''' revient à un appel des fonctions '''write()''' et '''read()''' {{underline|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)'''.
-That's all there is to using the SPI protocol with the FT232H and the Adafruit Python GPIO library!
+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!
-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.
+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 ==

@@ Ligne 5 : / Ligne 5 : @@
 == FT232 en mode Bus SPI ==
-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.
+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.
-When using SPI with the FT232H the following pins will have a special meaning:
+En utilisant SPI avec le FT232H, les broches suivantes ont une signification spéciale:
-* '''D0 - SCK / Clock signal''' :  This will be the clock that tells devices when to sample and write data.
+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.
-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.
+Vous aurez besoin de créer une instance de la classe Adafruit_GPIO.FT232H.SPI pour utiliser le bus SPI du FT232H sous Python:
 <syntaxhighlight lang="python">
 import Adafruit_GPIO.FT232H as FT232H
-# Temporarily disable FTDI serial drivers.
+# Désactiver temporairement le pilote FTDI série.
 FT232H.use_FT232H()
-# Find the first FT232H device.
+# Trouver le premier périphérique FT232H.
 ft232h = FT232H.FT232H()
-# Create a SPI interface from the FT232H using pin 8 (C0) as chip select.
+# Créer une interface SPI du FT232H en utilisant la broche 8 (C0) comme signal ''chip select''.
-# Use a clock speed of 3mhz, SPI mode 0, and most significant bit first.
+# 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)
-# Write three bytes (0x01, 0x02, 0x03) out using the SPI protocol.
+# Ecrire 3 octets/bytes (0x01, 0x02, 0x03) en utilisant le protocole SPI.
 spi.write([0x01, 0x02, 0x03])
 </syntaxhighlight>
-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.
+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).
-Next the code creates a FT232H object also like was done in the GPIO example.
+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" .
-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.
+{{traduction}}
 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.