Serielle periphere Grenzfläche in Arduino

Arduino ist eine elektronische Entwicklungskarte, die mit einem Mikrocontroller ausgeführt wird. Es verarbeitet Anweisungen und generiert die gewünschte Ausgabe. Die Kommunikation spielt eine wichtige Rolle bei der Verarbeitung von Arduino -Code. Um dies zu tun, hat Arduino mehrere Kommunikationsprotokolle wie USAT, I2C und SPI. Weitere Informationen zu Kommunikationsprotokollen im Detail finden Sie hier. Heute werden wir diskutieren, wie SPI (serielle periphere Grenzfläche) in Arduino verwendet wird.

Serielle periphere Grenzfläche (SPI)

Die serielle periphere Grenzfläche (SPI) ist ein synchrones serielles Datenprotokoll, das von Arduino -Mikrocontrollern für Kommunikationszwecke mit einem oder mehreren peripheren Geräten schnell über kurze Strecken verwendet wird. Es kann auch für die Kommunikation zwischen zwei Mikrocontrollern verwendet werden.

SPI ist eine vollständige Duplex -Kommunikation, was bedeutet, dass sie gleichzeitig Daten senden und lesen kann. Unter allen drei Kommunikationsprotokollen (USAart, SPI und I2C) in Arduino SPI ist am schnellsten. SPI verfügt über Anwendungen.

SPI funktioniert mit vier Zeilen:

• SCK: Taktsignal die Datenübertragung zwischen Master- und Sklavengeräten synchronisieren.
• Miso: (Meister im Sklaven) oder MISO ist eine Datenlinie für Slave, die Daten an Master zurücksenden kann.
• Mosi: (Master Sklave in) oder MOSI ist eine Datenlinie für Master, um Daten an Sklavengeräte und Peripheriegeräte zu senden.
• SS: (Sklave auswählen) Es handelt sich um die von Master verwendete Linie, um ein bestimmtes Slave -Gerät auszuwählen. Es informiert das Slave -Gerät, an die Daten gesendet oder empfangen werden sollen.

Aktualisieren: Gemäß der Arduino -Offiziellen Dokumentation SPI in Arduino unterstützt diese Terminologien nicht mehr. Die folgende Tabelle zeigt die neuen Terminologien:

Spi Pinout in Arduino Uno

SPI -Protokoll wird von mehreren Arduino -Boards hier unterstützt. Wir haben die Unterstützung von Arduino uno für SPI besprochen. Im Folgenden sind die von Arduino Uno für die serielle periphere Kommunikation verwendete Stifte verwendet.

SPI in der Master -Slave -Konfiguration

Das Anschließen eines Master -Geräts mit Single Slave ist einfach. Wir müssen beide nur mit demselben Stift verbinden. Sobald sowohl das Master als auch das Slave -Gerät wie in Bild unten gezeigt sind. Zunächst müssen wir die SS (Slave Select -Zeile) auf dem Master -Gerät auf niedrig einstellen. Es bleibt während der Datenübertragung niedrig. Low SS -Linie bereiten den Sklaven vor, um Daten zu senden oder zu empfangen. Sobald der SS niedrig ist, kann das Gerät Daten über die MOSI -Linie senden und Taktsignale für die synchrone Kommunikation mit dem SCLK -Pin erstellen.

SPI in einer einzelnen Master -Slave -Konfiguration

SPI unterstützt auch mehrere Sklavengeräte, eine separate SS -Linie (Slave Select) für jeden einzelnen Sklaven. Im Gegensatz zu Single Slave hier benötigt Master für jeden Sklaven eine separate SS -Linie. Das Arbeiten der Konfiguration mit einer einzelnen und mehreren Slave -Geräten ist irgendwie ähnlich. Master -Gerät Ziehen Sie die SS -Linie eines bestimmten Sklaven auf niedrig, das Slave -Gerät informiert, dass Master Daten von diesem Sklaven senden oder empfangen wird.

Das folgende Bild veranschaulicht eine einzelne Master -Konfiguration mehrerer Slave -Geräte -Konfigurationen.

Die Daisy -Kettenkonfiguration ist eine weitere Möglichkeit, mehrere Sklavengeräte zu verbinden. Wo Master für jeden Sklaven nicht mehrere SS -Linien benötigt. Tatsächlich ist eine einzelne SS -Linie mit dem ersten Slave -Gerät verbunden. Sobald das Master -Gerät die SS -Linie auf niedrig gezogen hat, sendet es Signale an das gesamte Slave -Gerät, um sie für die Kommunikation am Mosi -Pin bereitzustellen. Master Device Senden Sie Daten an die Mosi -Pin des ersten Sklavengeräts.

Gleichzeitig sendet der Master ein Taktsignal am SCK -Pin. Daten werden von einem Sklaven an einen anderen gesendet und der SS -Pin ist während dieser Dauer so niedrig eingestellt. Der Master sollte genug Taktsignal senden, um es bis zum letzten Sklavengerät zu erreichen. Daten, die von einem bestimmten Sklavengerät empfangen werden.

Das folgende Bild zeigt die Daisy -Kettenkonfiguration.

So programmieren Sie Arduino für die SPI -Kommunikation

Jetzt nehmen wir zwei Arduino -Boards und übergeben eine Schnur von einem Arduino -Board, der Meister an den zweiten Arduino ist, der als Sklave fungiert. Denken Sie daran, zwei separate Fenster von Arduino IDE zu öffnen, bevor Code hochgeladen wird. Andernfalls besteht eine hohe Wahrscheinlichkeit, dass der gleiche Code in beiden Arduino hochgeladen wird.

Wählen Sie vor dem Hochladen von Code den COM -Port, an dem Arduino verbunden ist. Beide Arduino sollten an getrennten COM -Ports angeschlossen werden.

Schaltkreis

Schließen Sie zwei Arduino -Boards an, wie gezeigt in der unteren Schaltung. Stellen Sie sicher, dass Sie beide Boards mit GND anschließen und alle anderen vier SPI.

Hardware

Unten finden Sie das Hardware -Image von zwei Arduino -Boards, die über das USB -Kabel mit dem PC verbunden sind.

Hauptkennziffer

/*Master Arduino Code*/
#include /*SPI -Bibliothek inklusive* /
void setup ()
Serie.Beginnen Sie (115200); /*Baudrate für serielle Kommunikation*/
DigitalWrite (SS, hoch); /*(Ss) Slave auswählen Zeile deaktiviert*/
Spi.Start(); /*SPI -Kommunikation beginnt*//
Spi.setClockDivider (spi_clock_div8); /*Uhr geteilt durch 8*//

void Loop ()
char char_str; /*Variable definiert, um Daten zu senden*/
DigitalWrite (SS, niedrig); /*(Ss) Slave auswählen aktiviert*/
für (const char * p = "LinuxHint.Com \ r "; char_str =*p; p ++) /*Test String gesendet* /
Spi.Transfer (char_str); /*SPI -Übertragung beginnt*/
Serie.print (char_str); /*String ist gedruckt*/

DigitalWrite (SS, hoch);
Verzögerung (2000);

Hier im obigen Code haben wir zuerst die SPI -Bibliothek für die Kommunikation aufgenommen. Als nächstes haben wir mit der Definition der Baud -Rate festgestellt. SPI -Kommunikation beginnen Spi.Start() wird eingesetzt.

Im Loop -Teil des Code wird eine Zeichen -Variable definiert, um die Zeichenfolge zu speichern, die wir Slave Arduino senden werden. Als nächstes eine Zeichenfolge „LinuxHint.Com ” wird definiert, was mit dem SPI auf Slave Arduino übertragen wird.überweisen(). Sehen Sie die Eingangszeichenfolge auf dem Seriennonitor an Serie.drucken() Funktion wird verwendet.

Sklavencode

/*Slave Arduino Code*//
#include /*SPI -Bibliothek inklusive* /
Zeichenpuffer [50]; /*Puffer, das für die gespeicherte Zeichenfolge von Master*/definiert ist
flüchtiger Byte -Index; /*String -Daten speichern*/
flüchtiger boolescher Prozess;
void setup ()
Serie.Beginnen Sie (115200);
PinMode (Miso, Ausgabe); /*Miso als Ausgabe gesetzt, um Daten an master*/zu senden
Spcr | = _bv (spe); /*SPI im Sklavenmodus aktiv*/
Index = 0; /*Puffer leer*/
prozess = falsch;
Spi.attachterrupt (); /*Interrupt einschalten*/

ISR (SPI_STC_VECT) /*SPI Interrupt Routine* /
byte char_str = spdr; /*Byte aus dem SPI -Datenregister lesen*/
if (index < sizeof buffer)
Buffer [index ++] = char_str; /*Daten, die im Index von Array Buff*/gespeichert sind*/
if (char_str == '\ r') /*Überprüfen Sie, ob die Zeichenfolge beendet* /
prozess = wahr;


void Loop ()
if (prozess)
prozess = falsch; /*Prozessreset*/
Serie.println (puffer); /*Empfangenes Array, das auf Serienmonitor gedruckt wurde*/
Index = 0; /*Schaltfläche auf Null zurücksetzen*/

Der obere Code wird auf Slave Arduino hochgeladen, wo wir mit der Definition von drei Variablen begonnen haben Puffer, Index und Prozess. Die Puffervariable speichert die Eingangszeichenfolge aus dem Master Arduino, während der Index nach dem Index der Elemente in der Zeichenfolge sucht und sobald der gesamte String der Prozess gedruckt ist. Danach wird der Sklave wieder anfangen, Daten von Master Arduino zu erhalten und auf dem Serienmonitor gedruckt zu werden.

Ausgang

Die Ausgabe ist in zwei verschiedenen Fenstern der Arduino -IDE zu sehen. Die Ausgabe von Master- und Slave Arduino wird auf dem Serienmonitor gedruckt.

Abschluss

Die serielle periphere Schnittstelle ist ein wichtiges Kommunikationsprotokoll, das in der Arduino -Programmierung verwendet wird, mit der Benutzer mehrere Geräte mithilfe einer einzigen Arduino -Karte kontrollieren können. SPI ist schneller als USAart- und I2C -Protokoll. Es kann in zwei verschiedenen Konfigurationen Single Master mit Einzelsklaven oder mehreren Sklaven implementiert werden. Dieser Artikel gibt einen Einblick, wie Arduino für die SPI -Kommunikation verbunden werden kann.