- Was ist SPI?
- Arbeiten von SPI
- SPI-Pins in Arduino UNO
- Verwenden von SPI in Arduino
- Erforderliche Komponenten für die Arduino SPI-Kommunikation
- Schaltplan der Arduino SPI-Kommunikation
- So programmieren Sie Arduino für die SPI-Kommunikation:
- Erklärung zur Arduino SPI-Masterprogrammierung
- Erklärung zur Arduino SPI-Slave-Programmierung
- Wie funktioniert SPI auf Arduino? - Lass es uns testen!
Ein Mikrocontroller verwendet viele verschiedene Protokolle, um mit verschiedenen Sensoren und Modulen zu kommunizieren. Es gibt viele verschiedene Arten von Kommunikationsprotokollen für die drahtlose und drahtgebundene Kommunikation, und die am häufigsten verwendete Kommunikationstechnik ist die serielle Kommunikation. Bei der seriellen Kommunikation werden Daten nacheinander bitweise über einen Kommunikationskanal oder -bus gesendet. Es gibt viele Arten der seriellen Kommunikation wie UART-, CAN-, USB-, I2C- und SPI-Kommunikation.
In diesem Tutorial lernen wir das SPI-Protokoll und seine Verwendung in Arduino kennen. Wir werden das SPI-Protokoll für die Kommunikation zwischen zwei Arduinos verwenden. Hier fungiert ein Arduino als Master und ein anderer als Slave. Zwei LEDs und Drucktasten werden an beide Arduino angeschlossen. Um die SPI-Kommunikation zu demonstrieren, steuern wir die Master-seitige LED über den Druckknopf auf der Slave-Seite und umgekehrt mithilfe des seriellen SPI-Kommunikationsprotokolls.
Was ist SPI?
SPI (Serial Peripheral Interface) ist ein serielles Kommunikationsprotokoll. Die SPI-Schnittstelle wurde 1970 von Motorola gefunden. SPI verfügt über eine Vollduplex-Verbindung, dh die Daten werden gleichzeitig gesendet und empfangen. Das heißt, ein Master kann Daten an einen Slave senden und ein Slave kann gleichzeitig Daten an den Master senden. SPI ist synchrone serielle Kommunikation, dh die Uhr wird für Kommunikationszwecke benötigt.
Die SPI-Kommunikation wurde zuvor in anderen Mikrocontrollern erläutert:
- SPI-Kommunikation mit dem PIC-Mikrocontroller PIC16F877A
- Schnittstelle zwischen 3,5-Zoll-TFT-LCD-Touchscreen und Raspberry Pi
- Programmierung eines AVR-Mikrocontrollers mit SPI-Pins
- Schnittstelle zwischen dem grafischen LCD Nokia 5110 und Arduino
Arbeiten von SPI
Ein SPI verfügt über eine Master / Slave-Kommunikation über vier Leitungen. Ein SPI kann nur einen Master und mehrere Slaves haben. Ein Master ist normalerweise ein Mikrocontroller und die Slaves können ein Mikrocontroller, Sensoren, ADC, DAC, LCD usw. sein.
Unten sehen Sie die Blockdiagrammdarstellung des SPI- Masters mit Single Slave.
SPI hat die folgenden vier Zeilen: MISO, MOSI, SS und CLK
- MISO (Master in Slave Out) - Die Slave-Leitung zum Senden von Daten an den Master.
- MOSI (Master Out Slave In) - Die Master-Leitung zum Senden von Daten an die Peripheriegeräte.
- SCK (Serial Clock) - Die Taktimpulse, die die vom Master erzeugte Datenübertragung synchronisieren.
- SS (Slave Select) - Der Master kann diesen Pin verwenden, um bestimmte Geräte zu aktivieren und zu deaktivieren.
SPI-Master mit mehreren Slaves
Um die Kommunikation zwischen Master und Slave zu starten, müssen Sie den Slave Select (SS) -Pin des erforderlichen Geräts auf LOW setzen, damit es mit dem Master kommunizieren kann. Wenn es hoch ist, ignoriert es den Master. Auf diese Weise können mehrere SPI-Geräte dieselben MISO-, MOSI- und CLK-Master-Leitungen gemeinsam nutzen. Wie Sie im obigen Bild sehen können, gibt es vier Slaves, bei denen SCLK, MISO, MOSI gemeinsam mit dem Master verbunden sind und die SS jedes Slaves separat mit einzelnen SS-Pins (SS1, SS2, SS3) des Masters verbunden ist. Durch Setzen des erforderlichen SS-Pins LOW kann ein Master mit diesem Slave kommunizieren.
SPI-Pins in Arduino UNO
Das Bild unten zeigt die SPI-Pins von Arduino UNO (in roter Box).
|
SPI-Leitung |
Pin in Arduino |
|
MOSI |
11 oder ICSP-4 |
|
MISO |
12 oder ICSP-1 |
|
SCK |
13 oder ICSP-3 |
|
SS |
10 |
Verwenden von SPI in Arduino
Bevor Sie mit der Programmierung für die SPI-Kommunikation zwischen zwei Arduinos beginnen. Wir müssen etwas über die in Arduino IDE verwendete Arduino SPI-Bibliothek lernen.
Die Bibliothek
1. SPI.begin ()
VERWENDUNG: Zum Initialisieren des SPI-Busses durch Einstellen von SCK, MOSI und SS auf Ausgänge, Ziehen von SCK und MOSI auf niedrig und SS auf hoch.
2. SPI.setClockDivider (Teiler)
VERWENDUNG: Zum Einstellen des SPI-Taktteilers relativ zur Systemuhr. Die verfügbaren Teiler sind 2, 4, 8, 16, 32, 64 oder 128.
Teiler:
- SPI_CLOCK_DIV2
- SPI_CLOCK_DIV4
- SPI_CLOCK_DIV8
- SPI_CLOCK_DIV16
- SPI_CLOCK_DIV32
- SPI_CLOCK_DIV64
- SPI_CLOCK_DIV128
3. SPI.attachInterrupt (Handler)
USE: Diese Funktion wird aufgerufen, wenn ein Slave-Gerät Daten vom Master empfängt.
4. SPI.transfer (val)
GEBRAUCH: Mit dieser Funktion werden die Daten gleichzeitig zwischen Master und Slave gesendet und empfangen.
Beginnen wir nun mit der praktischen Demonstration des SPI-Protokolls in Arduino. In diesem Tutorial werden wir zwei Arduino verwenden, eines als Master und eines als Slave. Beide Arduino sind separat mit einer LED und einem Druckknopf verbunden. Die Master-LED kann über den Druckknopf des Slave-Arduino gesteuert werden, und die LED des Slave-Arduino kann über den Druckknopf des Master-Arduino unter Verwendung des in Arduino vorhandenen SPI-Kommunikationsprotokolls gesteuert werden.
Erforderliche Komponenten für die Arduino SPI-Kommunikation
- Arduino UNO (2)
- LED (2)
- Druckknopf (2)
- Widerstand 10k (2)
- Widerstand 2,2 k (2)
- Steckbrett
- Kabel anschließen
Schaltplan der Arduino SPI-Kommunikation
Das folgende Schaltbild zeigt, wie SPI unter Arduino UNO verwendet wird. Sie können jedoch das gleiche Verfahren für die Arduino Mega SPI-Kommunikation oder die Arduino Nano SPI-Kommunikation anwenden. Mit Ausnahme der PIN-Nummer bleibt fast alles beim Alten. Sie müssen die Pinbelegung von Arduino Nano oder Mega überprüfen, um die Arduino Nano SPI-Pins und Arduino Mega-Pins zu finden. Sobald Sie dies getan haben, ist alles andere gleich.
Ich habe die oben gezeigte Schaltung über ein Steckbrett gebaut. Sie können die Schaltungskonfiguration sehen, die ich zum Testen unten verwendet habe.
So programmieren Sie Arduino für die SPI-Kommunikation:
Dieses Tutorial enthält zwei Programme, eines für Master Arduino und eines für Slave Arduino. Vollständige Programme für beide Seiten finden Sie am Ende dieses Projekts.
Erklärung zur Arduino SPI-Masterprogrammierung
1. Zunächst müssen wir die SPI-Bibliothek für die Verwendung von SPI-Kommunikationsfunktionen einbeziehen.
#einschließen
2. In void setup ()
- Wir starten die serielle Kommunikation mit der Baudrate 115200.
Serial.begin (115200);
- Bringen Sie die LED an Pin 7 und die Drucktaste an Pin 2 an und setzen Sie die Pins OUTPUT bzw. INPUT.
pinMode (ipbutton, INPUT); PinMode (LED, OUTPUT);
- Als nächstes beginnen wir mit der SPI-Kommunikation
SPI.begin ();
- Als nächstes stellen wir den Clockdivider für die SPI-Kommunikation ein. Hier haben wir Teiler 8 gesetzt.
SPI.setClockDivider (SPI_CLOCK_DIV8);
- Setzen Sie dann den SS-Pin auf HIGH, da wir keine Übertragung zum Slave-Arduino gestartet haben.
digitalWrite (SS, HIGH);
3. In void loop ():
- Wir lesen den Status des mit Pin2 (Master Arduino) verbundenen Druckknopf-Pins, um diesen Wert an den Slave Arduino zu senden.
buttonvalue = digitalRead (ipbutton);
- Legen Sie die Logik für die Einstellung des x-Werts (an den Slave zu senden) in Abhängigkeit von der Eingabe von Pin 2 fest
if (buttonvalue == HIGH) { x = 1; } else { x = 0; }}
- Bevor wir den Wert senden, müssen wir den Slave-Auswahlwert auf LOW setzen, um die Übertragung vom Master zum Slave zu starten.
digitalWrite (SS, LOW);
- Hier kommt der wichtige Schritt: In der folgenden Anweisung senden wir den in der Mastersend- Variablen gespeicherten Druckknopfwert an das Slave-Arduino und empfangen auch den Wert vom Slave, der in der Mastereceive- Variablen gespeichert wird.
Mastereceive = SPI.transfer (Mastersend);
- Danach schalten wir je nach Mastereceive- Wert die Master-Arduino-LED ein oder aus.
if (Mastereceive == 1) { digitalWrite (LED, HIGH); // Setzt Pin 7 auf HIGH Serial.println ("Master LED ON"); } else { digitalWrite (LED, LOW); // Setzt Pin 7 LOW Serial.println ("Master LED OFF"); }}
Hinweis: Wir verwenden serial.println () , um das Ergebnis in Serial Motor der Arduino IDE anzuzeigen. Überprüfen Sie das Video am Ende.
Erklärung zur Arduino SPI-Slave-Programmierung
1. Zunächst müssen wir die SPI-Bibliothek für die Verwendung von SPI-Kommunikationsfunktionen einbeziehen.
#einschließen
2. In void setup ()
- Wir starten die serielle Kommunikation mit der Baudrate 115200.
Serial.begin (115200);
- Bringen Sie die LED an Pin 7 und die Drucktaste an Pin 2 an und setzen Sie die Pins OUTPUT bzw. INPUT.
pinMode (ipbutton, INPUT); PinMode (LED, OUTPUT);
- Der wichtige Schritt hierbei sind die folgenden Aussagen
PinMode (MISO, OUTPUT);
Die obige Anweisung setzt MISO als OUTPUT (Daten müssen an Master IN gesendet werden). Die Daten werden also über MISO von Slave Arduino gesendet.
- Schalten Sie nun SPI im Slave-Modus mithilfe des SPI-Steuerregisters ein
SPCR - = _BV (SPE);
- Schalten Sie dann den Interrupt für die SPI-Kommunikation ein. Wenn Daten vom Master empfangen werden, wird die Interrupt-Routine aufgerufen und der empfangene Wert vom SPDR (SPI-Datenregister) übernommen.
SPI.attachInterrupt ();
- Der Wert vom Master wird aus SPDR übernommen und in der Slavereceived- Variablen gespeichert. Dies erfolgt in der folgenden Interrupt-Routine-Funktion.
ISR (SPI_STC_vect) { Slavereceived = SPDR; empfangen = wahr; }}
3. Als nächstes setzen wir in void loop () die Slave-Arduino-LED so, dass sie je nach dem vom Slaver empfangenen Wert ein- oder ausgeschaltet wird.
if (Slavereceived == 1) { digitalWrite (LEDpin, HIGH); // Setzt Pin 7 als HIGH LED ON Serial.println ("Slave LED ON"); } else { digitalWrite (LEDpin, LOW); // Setzt Pin 7 als LOW LED OFF Serial.println ("Slave LED OFF"); }}
- Als nächstes lesen wir den Status des Slave Arduino-Druckknopfs und speichern den Wert in Slavesend , um den Wert an Master Arduino zu senden, indem wir dem SPDR-Register einen Wert geben.
buttonvalue = digitalRead (Buttonpin); if (buttonvalue == HIGH) {x = 1; } else {x = 0; } Slavesend = x; SPDR = Slavesend;
Hinweis: Wir verwenden serial.println () , um das Ergebnis in Serial Motor der Arduino IDE anzuzeigen. Überprüfen Sie das Video am Ende.
Wie funktioniert SPI auf Arduino? - Lass es uns testen!
Unten sehen Sie das Bild der endgültigen Einrichtung für die SPI-Kommunikation zwischen zwei Arduino-Boards.
Wenn der Druckknopf auf der Master-Seite gedrückt wird, leuchtet die weiße LED auf der Slave-Seite auf.
Und wenn der Druckknopf auf der Slave-Seite gedrückt wird, leuchtet die rote LED auf der Master-Seite auf.
Sie können das folgende Video ansehen, um die Demonstration der Arduino SPI-Kommunikation zu sehen. Wenn Sie Fragen haben, hinterlassen Sie diese bitte im Kommentarbereich. Nutzen Sie unsere Foren.