C’est le premier de deux chapitres dans lesquels nous allons commencer à étudier le bus de données SPI, et comment nous pouvons contrôler les périphériques qui l’utilisent avec nos systèmes Arduino.
Le bus SPI peut sembler être une interface complexe à maîtriser, mais avec une brève étude de cette explication et des exemples pratiques, vous deviendrez bientôt un maître de bus! Pour ce faire, nous allons apprendre la théorie nécessaire, puis l’appliquer en contrôlant une variété d’appareils. Dans ce tutoriel, les choses seront aussi simples que possible.
Mais d’abord, qu’est-ce que c’est ? Et une théorie
SPI est un acronyme pour « Interface périphérique série »” Il s’agit d’un bus de données série synchrone – les données peuvent voyager dans les deux sens en même temps, contrairement (par exemple) au bus I2C qui ne peut pas le faire. Pour permettre une transmission de données synchrone, le bus SPI utilise quatre fils. Ils sont appelés:
- MOSI-Master-out, Slave-in. Cette ligne transporte les données de notre Arduino vers le (s) périphérique(s) contrôlé(s) par SPI;
- MISO-Master–in, Slave out. Cette ligne transporte les données du (des) dispositif(s) contrôlé(s) par SPI vers l’Arduino;
- SS–Slave- sélectionnez. Cette ligne indique à l’appareil du bus que nous souhaitons communiquer avec lui. Chaque périphérique SPI a besoin d’une ligne SS unique vers l’Arduino;
- Horloge SCK–Serial.
Dans ces tutoriels, nous considérons la carte Arduino comme le maître et les périphériques SPI comme des esclaves. Sur nos cartes Arduino Uno et compatibles, les broches utilisées sont:
- SS–digital 10. Vous pouvez utiliser d’autres broches numériques, mais 10 est généralement la valeur par défaut car elle est à côté des autres broches SPI ;
- MOSI-digital 11;
- MISO-digital 12;
- SCK-digital 13;
Utilisateurs Arduino Mega – MISO est 50, MOSI est 51, SCK est 52 et SS est généralement 53. Si vous utilisez un Arduino Leonardo, les broches SPI sont sur les broches d’en-tête ICSP. Voir ici pour plus d’informations. Vous pouvez contrôler un ou plusieurs appareils avec le bus SPI. Par exemple, pour un périphérique, le câblage serait:
Les données vont et viennent le long des lignes MOSI et MISO entre notre Arduino et le périphérique SPI. Cela ne peut se produire que lorsque la ligne SS est définie sur LOW. En d’autres termes, pour communiquer avec un périphérique SPI particulier sur le bus, nous réglons la ligne SS sur ce périphérique sur LOW, puis communiquons avec lui, puis remettons la ligne sur HIGH. Si nous avons deux périphériques SPI ou plus sur le bus, le câblage ressemblerait à ce qui suit:
Remarquez comment il y a deux lignes SS – nous en avons besoin pour chaque périphérique SPI sur le bus. Vous pouvez utiliser n’importe quelle broche de sortie numérique libre sur votre Arduino comme ligne SS. N’oubliez pas d’avoir toutes les lignes SS hautes à l’exception de la ligne connectée à l’appareil SPI que vous souhaitez utiliser à ce moment-là.
Les données sont envoyées au périphérique SPI sous forme d’octets. Vous devez savoir maintenant que huit bits font un octet, représentant donc un nombre binaire avec une valeur comprise entre zéro et 255.
Lors de la communication avec nos appareils SPI, nous devons d’abord savoir de quelle manière l’appareil traite les données – MSB ou LSB. MSB (bit le plus significatif) est le côté gauche du nombre binaire, et LSB (bit le moins significatif) est le côté droit du nombre. C’est-à-dire:
Outre l’envoi de valeurs numériques le long du bus SPI, les nombres binaires peuvent également représenter des commandes. Vous pouvez représenter huit paramètres marche / arrêt en utilisant un octet de données, de sorte que les paramètres d’un appareil peuvent être définis en envoyant un octet de données. Ces paramètres varient en fonction de chaque appareil et doivent être illustrés dans la fiche technique de l’appareil en question. Par exemple, un potentiomètre numérique IC avec six pots:
Cet appareil nécessite deux octets de données. L’octet ADDR indique à l’appareil lequel des six potentiomètres à contrôler (numérotés de 0 à 5), et l’octet de DONNÉES est la valeur du potentiomètre (0 ~ 255). Nous pouvons utiliser des entiers pour représenter ces deux valeurs. Par exemple, pour régler le potentiomètre numéro deux à 125, nous enverrons 2 puis 125 à l’appareil.
Comment envoyer des données aux appareils SPI dans nos croquis ?
Tout d’abord, nous devons utiliser la bibliothèque SPI. Il est inclus avec l’installation par défaut de l’ Arduino Arduino, alors mettez ce qui suit au début de votre croquis:
#include "SPI.h"
Ensuite, dans void.setup() déclare quelle(s) broche(s) sera utilisée(s) pour SS et les définit comme SORTIE. Par exemple,
pinMode(ss, OUTPUT);
où ss a précédemment été déclaré comme un entier de valeur dix. Maintenant, pour activer le bus SPI :
SPI.begin();
et enfin nous devons indiquer à l’esquisse de quelle manière envoyer des données, MSB ou LSB en utilisant
SPI.setBitOrder(MSBFIRST);
ou
SPI.setBitOrder(LSBFIRST);
Quand il est temps d’envoyer des données en descendant le bus SPI jusqu’à notre appareil, trois choses doivent se produire. Tout d’abord, définissez la broche numérique avec SS sur faible:
digitalWrite(SS, LOW);
Envoyez ensuite les données en octets, un octet à la fois en utilisant:
SPI.transfer(value);
La valeur peut être un entier /octet compris entre zéro et 255. Enfin, lorsque vous avez terminé d’envoyer des données à votre appareil, terminez la transmission en réglant SS high:
digitalWrite(ss, HIGH);
L’envoi de données est assez simple. Généralement, la partie la plus difficile pour les gens est d’interpréter la fiche technique de l’appareil pour comprendre comment les commandes et les données doivent être structurées pour la transmission. Mais avec un peu de pratique, ces petits obstacles peuvent être surmontés.
Maintenant pour quelques exemples pratiques!
Il est temps de monter sur le bus SPI et de contrôler certains appareils. En suivant les exemples ci-dessous, vous devriez acquérir une compréhension pratique de la façon dont le bus et les périphériques SPI peuvent être utilisés avec nos cartes Arduino.
Exemple MCP4162
Notre premier exemple utilisera une partie simple mais intéressante – un potentiomètre numérique (nous en avons également utilisé un dans le tutoriel I2C). Cette fois, nous avons un rhéostat 10k de la série MCP4162:
Voici la fiche technique pour votre lecture. Pour le contrôler, nous devons envoyer deux octets de données – le premier octet est l’octet de contrôle, et heureusement pour cet exemple, il est toujours nul (car l’adresse de la valeur d’essuie-glace est 00h). Le deuxième octet est la valeur pour régler l’essuie-glace, qui contrôle la résistance. Donc, pour régler l’essuie-glace, nous devons faire trois choses dans notre esquisse
D’abord, définissez la ligne SS (sélection esclave) sur low:
digitalWrite(10, LOW);
Puis envoyez les deux octets de données:
SPI.transfer(0); // command byteSPI.transfer(value); // wiper value
Enfin, remettez la ligne SS à high:
SPI.transfer(0); // command byteSPI.transfer(value); // wiper value
Enfin, remettez la ligne SS à high:
digitalWrite(10, HIGH);
Facile à faire. La connexion à notre carte Arduino est très simple – considérez le brochage MCP4162:
Vdd se connecte à 5V, Vss à GND, CS à digital 10, SCK à digital 13, SDI à digital 11 et SDO à digital 12. Maintenant, parcourons les valeurs disponibles du MCP4162 dans l’esquisse suivante:
/* SPI bus demo using a Microchip MCP4162 digital potentiometer */#include "SPI.h" // necessary libraryint ss=10; // using digital pin 10 for SPI slave selectint del=200; // used for various delaysvoid setup(){ pinMode(ss, OUTPUT); // we use this for SS pin SPI.begin(); // wake up the SPI bus. SPI.setBitOrder(MSBFIRST); // our MCP4162 requires data to be sent MSB (most significant byte) first}void setValue(int value){ digitalWrite(ss, LOW); SPI.transfer(0); // send command byte SPI.transfer(value); // send value (0~255) digitalWrite(ss, HIGH);}void loop(){ for (int a=0; a<256; a++) { setValue(a); delay(del); } for (int a=255; a>=0; --a) { setValue(a); delay(del); }}
Maintenant pour voir les résultats de l’esquisse. Dans le clip vidéo suivant, nous parcourons la plage de résistance et mesurons la valeur du rhéostat avec un multimètre:
Avant d’aller de l’avant, si les potentiomètres numériques sont nouveaux pour vous, pensez à lire ce petit guide écrit par Microchip sur les différences entre les potentiomètres mécaniques et numériques.
Un autre exemple:
Dans cet exemple, nous utiliserons le potentiomètre numérique à quatre canaux Analog Devices AD5204 (fiche technique.PDF). Il contient quatre potentiomètres linéaires de 10k ohms, et chaque potentiomètre est réglable sur l’une des 256 positions.
Les paramètres sont volatils, ce qui signifie qu’ils ne sont pas mémorisés lorsque l’alimentation est coupée. Par conséquent, lorsque l’alimentation est appliquée, les potentiomètres sont tous préréglés au milieu de l’échelle. Notre exemple est l’exemple de montage en surface SOIC-24, mais il est également fabriqué au format DIP.
Pour faciliter la vie, il peut être soudé sur une carte de dérivation SOIC qui le convertit en un paquet traversant:
Dans cet exemple, nous allons contrôler la luminosité de quatre LED. Le câblage est très simple. Les brochages sont dans la fiche technique.
Et l’esquisse :
#include <SPI.h> // necessary libraryint ss=10; // using digital pin 10 for SPI slave selectint del=5; // used for fading delayvoid setup(){ pinMode(ss, OUTPUT); // we use this for SS pin SPI.begin(); // wake up the SPI bus. SPI.setBitOrder(MSBFIRST); // our AD5204 requires data to be sent MSB (most significant byte) first. See data sheet page 5 allOff(); // we do this as pot memories are volatile}void allOff()// sets all potentiometers to minimum value{ for (int z=0; z<4; z++) { setPot(z,0); }}void allOn()// sets all potentiometers to maximum value{ for (int z=0; z<4; z++) { setPot(z,255); }}void setPot(int pot, int level)// sets potentiometer 'pot' to level 'level'{ digitalWrite(ss, LOW); SPI.transfer(pot); SPI.transfer(level); digitalWrite(ss, HIGH);}void blinkAll(int count){ for (int z=0; zvoid indFade(){ for (int a=0; a<4; a++) { for (int l=0; l<255; l++) { setPot(a,l); delay(del); } for (int l=255; l>=0; --l) { setPot(a,l); delay(del); } }}void allFade(int count){ for (int a=0; a<count; a++)="" {="" for="" (int="" l="0;" l<255;="" l++)="" setpot(0,l);="" setpot(1,l);="" setpot(2,l);="" setpot(3,l);="" delay(del);="" }="">=0; --l) { setPot(0,l); setPot(1,l); setPot(2,l); setPot(3,l); delay(del); } }}void loop(){ blinkAll(3); delay(1000); indFade(); allFade(3);}
Les fonctions allOff() et allOn() sont utilisées pour régler les potentiomètres respectivement au minimum et au maximum. Nous utilisons allOff() au début de l’esquisse pour éteindre les LED. Cela est nécessaire car lors de la mise sous tension, les essuie-glaces sont généralement réglés à mi-chemin.
De plus, nous les utilisons dans la fonction blinkAll() pour bl clignoter les LEDs. La fonction setPot() accepte un numéro d’essuie-glace (0 ~ 3) et une valeur pour régler cet essuie-glace (0~255). Enfin, la fonction indFade() fait un bon travail de décoloration de chaque LED allumée et éteinte dans l’ordre – provoquant un effet très similaire à la modulation de largeur d’impulsion.
Enfin, le voici en action:
Alors voilà – j’espère une introduction facile à comprendre au monde du bus SPI et à la façon de contrôler les périphériques qui s’y trouvent. Comme toujours, c’est maintenant à vous et à votre imagination de trouver quelque chose à contrôler ou de faire face à d’autres manigances. Dans le prochain article SPI, nous examinerons la lecture et l’écriture de données via le bus SPI.
Cet article vous est présenté par pmdway.com – tout pour les fabricants et les passionnés d’électronique, avec livraison gratuite dans le monde entier.
Pour rester à jour avec les nouveaux messages sur tronixstuff.com , veuillez vous abonner à la liste de diffusion dans l’encadré à droite, ou suivez-nous sur twitter @tronixstuff.