En référence aux cartes Arduino Uno, Mega2560, Leonardo et autres:
Remarque: ceci est conçu comme une question de référence.
Réponses:
L' interface SPI ( Serial Peripheral Interface Bus ) est utilisée pour la communication entre plusieurs périphériques sur de courtes distances et à grande vitesse.
Il existe généralement un seul périphérique "maître" qui initie la communication et fournit l'horloge qui contrôle le débit de transfert de données. Il peut y avoir un ou plusieurs esclaves. Pour plusieurs esclaves, chacun a son propre signal "sélection d'esclave", décrit plus loin.
Dans un système SPI complet, vous aurez quatre lignes de signal:
Lorsque plusieurs esclaves sont connectés au signal MISO, ils sont supposés passer à l'état trois fois (conserver une haute impédance) de la ligne MISO jusqu'à ce qu'ils soient sélectionnés par Slave Select. Normalement, Slave Select (SS) devient faible pour l'affirmer. C'est-à-dire qu'il est actif bas. Une fois qu'un esclave particulier est sélectionné, il convient de configurer la ligne MISO en tant que sortie afin de pouvoir envoyer des données au maître.
Cette image montre la manière dont les données sont échangées lorsqu’un octet est envoyé:
Notez que trois signaux sont émis par le maître (MOSI, SCK, SS) et l’un est une entrée (MISO).
La séquence d'événements est la suivante:
SS va bas pour l'affirmer et activer l'esclaveSCKligne bascule pour indiquer quand les lignes de données doivent être échantillonnéesSCK( en utilisant la phase d'horloge par défaut)SCK(en utilisant la phase d'horloge par défaut), en modifiant MISO/ MOSIsi nécessaireSSpasse ensuite à l'état haut pour l'annuler.Notez que:
Les données étant envoyées et reçues sur la même impulsion d'horloge, il n'est pas possible pour l'esclave de répondre immédiatement au maître. Les protocoles SPI attendent généralement du maître qu'il demande des données lors d'une transmission et qu'il reçoive une réponse lors d'une transmission ultérieure.
En utilisant la bibliothèque SPI sur l’Arduino, effectuer un seul transfert ressemble à ceci dans le code:
byte outgoing = 0xAB;
byte incoming = SPI.transfer (outgoing);Exemple d'envoi uniquement (en ignorant les données entrantes):
#include <SPI.h>
void setup (void)
{
digitalWrite(SS, HIGH); // ensure SS stays high
SPI.begin ();
} // end of setup
void loop (void)
{
byte c;
// enable Slave Select
digitalWrite(SS, LOW); // SS is pin 10
// send test string
for (const char * p = "Fab" ; c = *p; p++)
SPI.transfer (c);
// disable Slave Select
digitalWrite(SS, HIGH);
delay (100);
} // end of loopLe code ci-dessus (qui envoie uniquement) peut être utilisé pour piloter un registre à décalage série de sortie. Ce ne sont que des périphériques de sortie, nous n'avons donc pas à nous soucier des données entrantes. Dans leur cas, la broche SS pourrait être appelée "broche" ou "verrou".
Le registre à décalage série 74HC595 et diverses bandes de LED en sont quelques exemples. Par exemple, cet écran LED de 64 pixels piloté par une puce MAX7219:
Dans ce cas, vous pouvez voir que le fabricant de la carte a utilisé des noms de signaux légèrement différents:
La plupart des conseils vont suivre un modèle similaire. Parfois, DIN est juste DI (Data In).
Voici un autre exemple, cette fois une carte d'affichage à LED à 7 segments (également basée sur la puce MAX7219):
Ceci utilise exactement les mêmes noms de signaux que l’autre tableau. Dans ces deux cas, vous pouvez voir que la carte n'a besoin que de 5 fils, les trois pour SPI, plus l'alimentation et la terre.
Vous pouvez échantillonner l'horloge SPI de quatre manières.
Le protocole SPI permet des variations sur la polarité des impulsions d'horloge. CPOL est la polarité de l'horloge et l'ACSP est la phase d'horloge.
Ceux-ci sont illustrés dans ce graphique:
Vous devez vous reporter à la fiche technique de votre appareil pour obtenir la phase et la polarité correctes. Il y aura généralement un diagramme qui montre comment échantillonner l'horloge. Par exemple, à partir de la fiche technique de la puce 74HC595:
Comme vous pouvez le constater, l'horloge est normalement basse (CPOL = 0) et est échantillonnée sur le bord d'attaque (CPHA = 0). Il s'agit donc du mode SPI 0.
Vous pouvez changer la polarité de l'horloge et la phase dans le code comme ceci (choisissez-en un, bien sûr):
SPI.setDataMode (SPI_MODE0);
SPI.setDataMode (SPI_MODE1);
SPI.setDataMode (SPI_MODE2);
SPI.setDataMode (SPI_MODE3);Cette méthode est déconseillée depuis les versions 1.6.0 et supérieures de l'IDE Arduino. Pour les versions récentes, vous modifiez le mode d'horloge dans l' SPI.beginTransactionappel, comme suit:
SPI.beginTransaction (SPISettings (2000000, MSBFIRST, SPI_MODE0)); // 2 MHz clock, MSB first, mode 0Le bit par défaut est le plus significatif en premier, mais vous pouvez demander au matériel de traiter le bit le moins significatif en premier, comme ceci:
SPI.setBitOrder (LSBFIRST); // least significant bit first
SPI.setBitOrder (MSBFIRST); // most significant bit firstEncore une fois, ceci est déconseillé dans les versions 1.6.0 et suivantes de l'IDE Arduino. Pour les versions récentes, vous modifiez l'ordre des bits dans l' SPI.beginTransactionappel, comme suit:
SPI.beginTransaction (SPISettings (1000000, LSBFIRST, SPI_MODE2)); // 1 MHz clock, LSB first, mode 2Le paramètre par défaut pour SPI consiste à utiliser la vitesse d'horloge système divisée par quatre, c'est-à-dire une impulsion d'horloge SPI toutes les 250 ns, en supposant une horloge de processeur de 16 MHz. Vous pouvez changer le diviseur d'horloge en utilisant setClockDividercomme ceci:
SPI.setClockDivider (divider);Où "diviseur" est l'un des:
Le taux le plus rapide est "diviser par 2" ou une impulsion d'horloge SPI toutes les 125 ns, en supposant une horloge de processeur de 16 MHz. Il faudrait donc 8 * 125 ns ou 1 µs pour transmettre un octet.
Cette méthode est déconseillée depuis les versions 1.6.0 et supérieures de l'IDE Arduino. Pour les versions récentes, vous modifiez la vitesse de transfert dans l' SPI.beginTransactionappel, comme suit:
SPI.beginTransaction (SPISettings (4000000, MSBFIRST, SPI_MODE0)); // 4 MHz clock, MSB first, mode 0Cependant, des tests empiriques montrent qu'il est nécessaire de disposer de deux impulsions d'horloge entre octets, de sorte que la cadence maximale à laquelle les octets peuvent être cadencés est de 1,125 µs chacun (avec un diviseur d'horloge de 2).
Pour résumer, chaque octet peut être envoyé à un débit maximal de un par 1,125 µs (avec une horloge de 16 MHz), ce qui donne un taux de transfert maximal théorique de 1 / 1,125 µs, soit 888 888 octets par seconde (sans le temps système comme le réglage SS sur).
Connexion via les broches numériques 10 à 13:
Connexion via l'en-tête ICSP:
Connexion via les broches numériques 50 à 52:
Vous pouvez également utiliser l'en-tête ICSP, similaire à l'Uno ci-dessus.
Le Leonardo et le Micro n’exposent pas les broches SPI sur les broches numériques, contrairement aux Uno et Mega. Votre seule option est d'utiliser les broches d'en-tête ICSP, comme illustré ci-dessus pour l'Uno.
Un maître peut communiquer avec plusieurs esclaves (mais un seul à la fois). Pour ce faire, il affirme SS pour un esclave et le désaffirme pour tous les autres. L'esclave qui a SS affirmé (généralement cela signifie LOW) configure sa broche MISO en tant que sortie afin que l'esclave, et cet esclave seul, puisse répondre au maître. Les autres esclaves ignorent les impulsions d'horloge entrantes si SS n'est pas affirmé. Ainsi, vous avez besoin d’un signal supplémentaire pour chaque esclave, comme ceci:
Dans ce graphique, vous pouvez voir que MISO, MOSI, SCK sont partagés entre les deux esclaves, mais chaque esclave a son propre signal SS (sélection d'esclave).
La spécification SPI ne spécifie pas les protocoles en tant que tels, il appartient donc à chaque paire maître / esclave de s’entendre sur la signification des données. Bien que vous puissiez envoyer et recevoir des octets simultanément, l’octet reçu ne peut pas être une réponse directe à l’octet envoyé (car ils sont assemblés simultanément).
Il serait donc plus logique pour une extrémité d'envoyer une requête (par exemple, 4 pourrait signifier "lister le répertoire du disque"), puis d'effectuer des transferts (éventuellement en envoyant des zéros vers l'extérieur) jusqu'à réception d'une réponse complète. La réponse peut se terminer par un caractère de nouvelle ligne ou 0x00.
Lisez la fiche technique de votre périphérique esclave pour connaître les séquences de protocole attendues.
L'exemple précédent montre que l'Arduino est le maître, envoyant des données à un périphérique esclave. Cet exemple montre comment l’Arduino peut être un esclave.
Connectez deux Arduino Unos ensemble avec les broches suivantes connectées l'une à l'autre:
13 (SCK)
+ 5v (si nécessaire)
Sur l’Arduino Mega, les broches sont 50 (MISO), 51 (MOSI), 52 (SCK) et 53 (SS).
Dans tous les cas, MOSI à une extrémité est connecté à MOSI à l'autre, vous ne les échangez pas (c'est-à-dire que vous n'avez pas MOSI <-> MISO). Le logiciel configure l'une des extrémités de MOSI (extrémité principale) en tant que sortie et l'autre extrémité (extrémité esclave) en tant qu'entrée.
#include <SPI.h>
void setup (void)
{
digitalWrite(SS, HIGH); // ensure SS stays high for now
// Put SCK, MOSI, SS pins into output mode
// also put SCK, MOSI into LOW state, and SS into HIGH state.
// Then put SPI hardware into Master mode and turn SPI on
SPI.begin ();
// Slow down the master a bit
SPI.setClockDivider(SPI_CLOCK_DIV8);
} // end of setup
void loop (void)
{
char c;
// enable Slave Select
digitalWrite(SS, LOW); // SS is pin 10
// send test string
for (const char * p = "Hello, world!\n" ; c = *p; p++)
SPI.transfer (c);
// disable Slave Select
digitalWrite(SS, HIGH);
delay (1000); // 1 seconds delay
} // end of loop#include <SPI.h>
char buf [100];
volatile byte pos;
volatile bool process_it;
void setup (void)
{
Serial.begin (115200); // debugging
// turn on SPI in slave mode
SPCR |= bit (SPE);
// have to send on master in, *slave out*
pinMode (MISO, OUTPUT);
// get ready for an interrupt
pos = 0; // buffer empty
process_it = false;
// now turn on interrupts
SPI.attachInterrupt();
} // end of setup
// SPI interrupt routine
ISR (SPI_STC_vect)
{
byte c = SPDR; // grab byte from SPI Data Register
// add to buffer if room
if (pos < sizeof buf)
{
buf [pos++] = c;
// example: newline means time to process buffer
if (c == '\n')
process_it = true;
} // end of room available
} // end of interrupt routine SPI_STC_vect
// main loop - wait for flag set in interrupt routine
void loop (void)
{
if (process_it)
{
buf [pos] = 0;
Serial.println (buf);
pos = 0;
process_it = false;
} // end of flag set
} // end of loopL'esclave est entièrement guidé par des interruptions, il peut donc faire d'autres choses. Les données SPI entrantes sont collectées dans une mémoire tampon et un indicateur est défini lorsqu'un "octet significatif" (dans ce cas, une nouvelle ligne) arrive. Cela indique à l'esclave de démarrer et de traiter les données.
Dans la suite du code ci-dessus, qui envoie des données d’un maître SPI à un esclave, l’exemple ci-dessous montre l’envoi de données à un esclave, le fait en faire quelque chose et renvoie une réponse.
Le maître est similaire à l'exemple ci-dessus. Cependant, un point important est la nécessité d'ajouter un léger délai (environ 20 microsecondes). Sinon, l'esclave n'a pas la possibilité de réagir aux données entrantes et de faire quelque chose avec.
L'exemple montre l'envoi d'une "commande". Dans ce cas, "a" (ajouter quelque chose) ou "s" (soustraire quelque chose). Cela montre que l'esclave est en train de faire quelque chose avec les données.
Après avoir activé la sélection par esclave (SS) pour lancer la transaction, le maître envoie la commande, suivie d’un nombre quelconque d’octets, puis déclenche la SS pour mettre fin à la transaction.
Un point très important est que l'esclave ne peut pas répondre à un octet entrant au même moment. La réponse doit être dans l'octet suivant. Cela est dû au fait que les bits envoyés et les bits reçus sont envoyés simultanément. Ainsi, pour ajouter quelque chose à quatre chiffres, nous avons besoin de cinq transferts, comme ceci:
transferAndWait ('a'); // add command
transferAndWait (10);
a = transferAndWait (17);
b = transferAndWait (33);
c = transferAndWait (42);
d = transferAndWait (0);Nous demandons d’abord une action sur le numéro 10. Mais nous n’obtenons pas de réponse avant le prochain transfert (celui sur 17). Toutefois, "a" sera défini sur la réponse à 10. Enfin, nous finirons par envoyer un "factice" numéro 0, afin d'obtenir la réponse pour 42.
#include <SPI.h>
void setup (void)
{
Serial.begin (115200);
Serial.println ();
digitalWrite(SS, HIGH); // ensure SS stays high for now
SPI.begin ();
// Slow down the master a bit
SPI.setClockDivider(SPI_CLOCK_DIV8);
} // end of setup
byte transferAndWait (const byte what)
{
byte a = SPI.transfer (what);
delayMicroseconds (20);
return a;
} // end of transferAndWait
void loop (void)
{
byte a, b, c, d;
// enable Slave Select
digitalWrite(SS, LOW);
transferAndWait ('a'); // add command
transferAndWait (10);
a = transferAndWait (17);
b = transferAndWait (33);
c = transferAndWait (42);
d = transferAndWait (0);
// disable Slave Select
digitalWrite(SS, HIGH);
Serial.println ("Adding results:");
Serial.println (a, DEC);
Serial.println (b, DEC);
Serial.println (c, DEC);
Serial.println (d, DEC);
// enable Slave Select
digitalWrite(SS, LOW);
transferAndWait ('s'); // subtract command
transferAndWait (10);
a = transferAndWait (17);
b = transferAndWait (33);
c = transferAndWait (42);
d = transferAndWait (0);
// disable Slave Select
digitalWrite(SS, HIGH);
Serial.println ("Subtracting results:");
Serial.println (a, DEC);
Serial.println (b, DEC);
Serial.println (c, DEC);
Serial.println (d, DEC);
delay (1000); // 1 second delay
} // end of loopLe code de l'esclave fait pratiquement tout dans la routine d'interruption (appelée lorsque les données SPI entrantes arrivent). Il prend l'octet entrant et ajoute ou soustrait selon "l'octet de commande" mémorisé. Notez que la réponse sera "collectée" la prochaine fois dans la boucle. C'est pourquoi le maître doit envoyer un dernier transfert "factice" pour obtenir la réponse finale.
Dans mon exemple, j'utilise la boucle principale pour détecter simplement quand SS monte et efface la commande sauvegardée. De cette façon, lorsque SS est à nouveau bas pour la transaction suivante, le premier octet est considéré comme l'octet de commande.
De manière plus fiable, cela se ferait avec une interruption. En d’autres termes, vous devez connecter physiquement le SS à l’une des entrées d’interruption (par exemple, sur l’Uno), connecter la broche 10 (SS) à la broche 2 (une entrée d’interruption) ou utiliser une interruption de changement de broche sur la broche 10.
Ensuite, l’interruption peut être utilisée pour remarquer que le SS est tiré bas ou haut.
// what to do with incoming data
volatile byte command = 0;
void setup (void)
{
// have to send on master in, *slave out*
pinMode(MISO, OUTPUT);
// turn on SPI in slave mode
SPCR |= _BV(SPE);
// turn on interrupts
SPCR |= _BV(SPIE);
} // end of setup
// SPI interrupt routine
ISR (SPI_STC_vect)
{
byte c = SPDR;
switch (command)
{
// no command? then this is the command
case 0:
command = c;
SPDR = 0;
break;
// add to incoming byte, return result
case 'a':
SPDR = c + 15; // add 15
break;
// subtract from incoming byte, return result
case 's':
SPDR = c - 8; // subtract 8
break;
} // end of switch
} // end of interrupt service routine (ISR) SPI_STC_vect
void loop (void)
{
// if SPI not active, clear current command
if (digitalRead (SS) == HIGH)
command = 0;
} // end of loopAdding results:
25
32
48
57
Subtracting results:
2
9
25
34
Adding results:
25
32
48
57
Subtracting results:
2
9
25
34Cela montre le délai entre l'envoi et la réception dans le code ci-dessus:
La version 1.6.0 de l'EDI a, dans une certaine mesure, modifié le fonctionnement de SPI. Vous devez toujours faire SPI.begin() avant d'utiliser SPI. Cela configure le matériel SPI. Cependant maintenant, lorsque vous êtes sur le point de commencer à communiquer avec un esclave , vous aussi faites SPI.beginTransaction()pour mettre en place SPI (pour cet esclave) avec le bon:
Lorsque vous avez fini de communiquer avec l'esclave, vous appelez SPI.endTransaction(). Par exemple:
SPI.beginTransaction (SPISettings (2000000, MSBFIRST, SPI_MODE0));
digitalWrite (SS, LOW); // assert Slave Select
byte foo = SPI.transfer (42); // do a transfer
digitalWrite (SS, HIGH); // de-assert Slave Select
SPI.endTransaction (); // transaction overJ'ajouterais une question préliminaire: quand / pourquoi utiliseriez-vous SPI? Un besoin de configuration multi-maîtres ou un très grand nombre d'esclaves inclinerait la balance vers I2C.
Ceci est une excellente question. Mes réponses sont:
Les deux méthodes ont leur place. I 2 C vous permet de connecter plusieurs périphériques à un seul bus (deux fils, plus la terre). Ce serait donc le choix à privilégier si vous aviez besoin d'interroger un nombre important de périphériques, peut-être assez rarement. Cependant, la vitesse de SPI pourrait être plus pertinente dans les situations où vous devez produire rapidement (par exemple une bande de LED) ou entrer rapidement (par exemple un convertisseur ADC).
Ma page sur SPI contient également des détails sur SPI bit-banged et sur l'utilisation de l'USART pour obtenir un second SPI matériel sur la puce Atmega328.
Are you going to cover the weirdness that is the Due's SPI?- Je ne sais rien du SPI de Due (à part présumer que le protocole global est le même). Vous êtes le bienvenu pour ajouter une réponse couvrant cet aspect.