Interface périphérique série dans Arduino

Arduino est une carte de développement électronique qui fonctionne à l'aide d'un microcontrôleur. Il traite les instructions et génère la sortie souhaitée. La communication joue un rôle majeur lors du traitement du code Arduino. Pour ce faire, Arduino a plusieurs protocoles de communication tels que USART, I2C et SPI. Pour en savoir plus sur les protocoles de communication en détail, cliquez ici. Aujourd'hui, nous discuterons de la façon dont SPI (interface périphérique série) est utilisée dans Arduino.

Interface périphérique série (SPI)

L'interface périphérique série (SPI) est un protocole de données série synchrone utilisé par les microcontrôleurs Arduino à des fins de communication avec un ou plusieurs dispositifs périphériques rapidement sur de courtes distances. Il peut également être utilisé pour la communication entre deux microcontrôleurs.

SPI est une communication duplex complète qui signifie qu'elle peut envoyer et lire des données en même temps. Parmi les trois protocoles de communication (USART, SPI et I2C) dans Arduino SPI est le plus rapide. SPI possède des applications où un débit de données élevé est requis, comme l'affichage du texte sur les écrans ou l'écriture de données sur la carte SD.

SPI fonctionne en utilisant quatre lignes:

• SCK: Signal d'horloge qui synchronisent le transfert de données entre les appareils maître et esclaves.
• MISO: (Maître en esclave) ou Miso est une ligne de données pour l'esclave qui peut renvoyer des données à Master.
• Mosi: (Master Out Slave In) ou MOSI est une ligne de données pour que Master puisse envoyer des données aux appareils esclaves et aux périphériques.
• SS: (Sélection d'esclaves) C'est la ligne utilisée par Master pour sélectionner un appareil esclave spécifique. Il informe l'appareil esclave auquel les données seront envoyées ou reçues.

Mise à jour: Selon la documentation officielle d'Arduino, SPI dans Arduino ne prend plus en charge ces terminologies. Le tableau ci-dessous montre les nouvelles terminologies:

Pinout SPI à Arduino Uno

Le protocole SPI est soutenu par plusieurs tableaux Arduino ici, nous avons discuté du support Arduino Uno pour SPI. Voici les broches utilisées par Arduino Uno pour la communication périphérique en série.

SPI dans la configuration d'esclaves maîtresse

La connexion d'un appareil maître à l'esclave unique est simple, nous devons simplement les connecter avec la même broche. Une fois que le périphérique maître et esclave est connecté comme indiqué dans l'image ci-dessous. Tout d'abord, nous devons définir le SS (ligne de sélection d'esclaves) sur l'appareil maître pour être bas. Il restera faible pendant la transmission des données. Low SS Line préparez l'esclave à envoyer ou à recevoir des données. Une fois que le SS est bas maître, l'appareil peut envoyer des données à l'aide de la ligne MOSI et peut produire des signaux d'horloge pour la communication synchrone à l'aide de la broche SCLK.

SPI dans une configuration d'esclaves multiple maître unique

SPI prend également en charge plusieurs dispositifs d'esclaves, une ligne SS (Select d'esclave) distincte est utilisée pour chaque esclave. Contrairement à l'esclave unique ici Master a besoin d'une ligne SS séparée pour chaque esclave. Le fonctionnement de la configuration des périphériques d'esclaves simples et multiples est en quelque sorte similaire. Le dispositif maître tire la ligne SS d'un esclave particulier à Low qui informe le dispositif esclave que Master va envoyer ou recevoir des données de cet esclave.

L'image suivante illustrer la configuration de périphérique d'esclaves maître unique unique.

La configuration de la chaîne de marguerite est un autre moyen de connecter plusieurs appareils esclaves. Où maître n'a pas besoin de plusieurs lignes SS pour chaque esclave en fait, une seule ligne SS est connectée à un premier appareil esclave. Une fois que le périphérique maître a tiré la ligne SS à bas, il envoie des signaux à tous les appareils esclaves pour être prêt pour la communication à Mosi Pin. Ensuite, l'appareil maître envoie des données à la broche MOSI du premier appareil esclave.

En même temps, le maître envoie un signal d'horloge à la broche SCK. Les données sont envoyées d'un esclave à l'autre et la broche SS est définie comme bas pendant cette durée. Le maître doit envoyer suffisamment de signal d'horloge pour l'atteindre jusqu'au dernier appareil esclave. Les données reçues d'un dispositif esclave particulier seront reçues par Master à sa broche MISO.

L'image suivante illustre la configuration de la chaîne de marguerite.

Comment programmer Arduino pour la communication SPI

Maintenant, nous prendrons deux planches Arduino et passerons une chaîne d'une carte Arduino qui est maître à Second Arduino qui agit comme esclave. N'oubliez pas d'ouvrir deux fenêtres distinctes d'Arduino IDE avant de télécharger le code Sinon, il y a de fortes chances de télécharger le même code dans les deux Arduino.

Avant de télécharger le code, sélectionnez le port com auquel Arduino est connecté. Les deux arduino doivent être connectés dans des ports COM séparés.

Circuit

Connectez deux planches Arduino comme indiqué dans le circuit ci-dessous. Assurez-vous de connecter les deux planches à GND et de connecter les quatre autres broches SPI de la broche 10 à 13 des deux Arduino.

Matériel

Vous trouverez ci-dessous l'image matérielle de deux planches Arduino connectées au PC à l'aide du câble USB.

Code maître

/ * Master Arduino Code * /
#include / * bibliothèque SPI incluse * /
void setup()
En série.commencer (115200); / * Taux de bauds défini pour la communication en série * /
DigitalWrite (SS, High); / * (SS) Sélectionner la ligne désactivée * /
Spice.commencer(); / * La communication SPI commence * /
Spice.setClockDivider (SPI_CLOCK_DIV8); / * Horloge divisée par 8 * /

VOID LOOP ()
char Char_str; / * Variable définie pour envoyer des données * /
DigitalWrite (SS, Low); / * (SS) SELECT SELECT Activé * /
pour (const char * p = "Linuxhint.Com \ r "; char_str = * p; p ++) / * chaîne de test envoyée * /
Spice.transfert (char_str); / * SPI Transfer Begin * /
En série.print (char_str); / * La chaîne est imprimée * /

DigitalWrite (SS, High);
Retard (2000);

Ici, dans le code ci-dessus, nous avons d'abord inclus la bibliothèque SPI pour la communication. Ensuite, nous avons commencé par définir le taux de bauds pour voir la sortie sur le moniteur série Monitor La ligne SELECT est désactivée à l'aide d'écriture numérique. Pour commencer la communication SPI Spice.commencer() est utilisé.

Dans la partie de boucle du code, une variable char est définie pour stocker la chaîne que nous allons envoyer Slave Arduino. Suivant une chaîne «Linuxhint.Com » est défini qui est transféré à l'esclave arduino en utilisant le SPI.transfert(). Pour voir la chaîne d'entrée sur le moniteur de série En série.imprimer() La fonction est utilisée.

Code d'esclaves

/ * Code arduino esclave * /
#include / * bibliothèque SPI incluse * /
tampon char [50]; / * Tampon défini pour stocker la chaîne reçue de maître * /
Index d'octets volatile; / * Enregistrer les données de chaîne * /
processus booléen volatil;
void setup()
En série.commencer (115200);
PinMode (miso, sortie); / * Miso set en sortie pour envoyer des données à Master * /
SPCR | = _BV (SPE); / * Spi en mode esclave actif * /
index = 0; / * Tampon vide * /
processus = false;
Spice.fixerterrupt (); / * activer l'interruption * /

ISR (SPI_STC_VECT) / * SPI Interrupt Routine * /
octet char_str = spdr; / * Lire l'octet à partir du registre de données SPI * /
if (index < sizeof buffer)
tampon [index ++] = char_str; / * Données enregistrées dans l'index du buff de tableau * /
if (char_str == '\ r') / * Vérifiez que la chaîne se termine * /
processus = true;


VOID LOOP ()
if (process)
processus = false; / * Procéder réinitialiser * /
En série.println (tampon); / * Réception reçue imprimée sur moniteur en série * /
index = 0; / * Réinitialiser le bouton à zéro * /

Le code ci-dessus est téléchargé sur esclave arduino où nous avons commencé par définir trois variables tampon, index et processus. La variable tampon stockera la chaîne d'entrée du maître Arduino tandis que l'index recherchera l'index des éléments à l'intérieur de la chaîne et une fois que toute la chaîne sera imprimée, le processus arrêtera le programme et réinitialise à zéro. Après quoi l'esclave commencera à recevoir des données de Master Arduino et sera imprimé sur moniteur en série.

Sortir

La sortie peut être vue dans deux fenêtres différentes de l'iDE Arduino. La sortie de l'arduino maître et esclave est imprimée sur un moniteur en série.

Conclusion

L'interface périphérique série est un important protocole de communication utilisé dans la programmation Arduino qui aide les utilisateurs à contrôler plusieurs appareils à l'aide d'une seule carte Arduino. SPI est plus rapide que le protocole USART et I2C. Il peut être implémenté dans deux configurations différentes maître avec esclave unique ou esclaves multiples. Cet article donne un aperçu de la façon dont Arduino peut être connecté pour la communication SPI.