ESP32-Boards unterstützen mehrere Kommunikationsprotokolle. Diese Protokolle umfassen serielles USART, I2C (IIC) und SPI. Neben diesen ESP32-Boards sind auch drahtlose Kommunikationsprotokolle wie WiFi, duales Bluetooth, ESP-Now, LoRa und viele mehr verfügbar. Heute konzentrieren wir uns auf das ESP32 SPI-Protokoll (Serial Peripheral Interface).
SPI (Serial Peripheral Interface) in ESP32
SPI oder Serial Peripheral Interface ist ein Kurzstrecken-Kommunikationsprotokoll, das in mehreren Mikrocontroller-Geräten wie ESP32 verwendet wird. Es ist ein synchrones Kommunikationsprotokoll, das hauptsächlich von Mikrocontrollern verwendet wird, um mit seinen Peripheriegeräten zu kommunizieren, sodass wir dieses Protokoll zum Lesen und Steuern von Geräten verwenden können, die das SPI-Protokoll unterstützen.
Die SPI-Kommunikation unterstützt die Master-Slave-Konfiguration, es gibt immer eine eines Meister die mehrere Slaves steuert. Es ist ein Vollduplex Kommunikation, sodass Daten gleichzeitig vom Master zum Slave und vom Slave zum Master ausgetauscht werden können.
SPI-Kommunikation in ESP32-Anforderungen vier verschiedene Pins zum Senden und Empfangen von Daten an Geräte. Im Folgenden sind diese vier Pins:
- SCK: Taktleitung bestimmt die Übertragungsgeschwindigkeit
- MISO: Master in Slave out ist der Übertragungsstift vom Slave zum Master
- RAUCH: Master out Slave in ist die Übertragungsleitung für Masterdaten zum Slave
- SS: Die Slave-Auswahlleitung hilft ESP32, einen bestimmten Slave auszuwählen und Daten von diesem Slave zu senden oder zu empfangen
Notiz: Bei einigen Geräten, die nur Slave sind und nicht als Master fungieren können, ist ihre Pin-Benennung anders, z.
-
- MISO wird durch ersetzt SDO (Serieller Datenausgang)
- RAUCH wird durch ersetzt SDI (Serial Data In)
SPI-Pins in ESP32
ESP32-Board wird mitgeliefert 4 verschiedene SPI-Peripheriegeräte, die in seinen Mikrocontroller integriert sind.
-
- SPI0: Nur für interne Speicherkommunikation – kann nicht mit externen SPI-Geräten verwendet werden
- SPI1: Nur für interne Speicherkommunikation – kann nicht mit externen SPI-Geräten verwendet werden
- SPI2: (HSPI) haben unabhängige Bussignale. Jeder Bus kann ableiten 3 Slave-Geräte
- SPI3: (VSPI) Bussignal ist unabhängig. Jeder Bus kann ableiten 3 Slave-Geräte
Die meisten ESP32-Boards verfügen über vorbelegte SPI-Pins für SPI2 und SPI3. Wenn es jedoch nicht zugewiesen ist, können wir SPI-Pins immer im Code zuweisen. Im Folgenden sind die SPI-Pins aufgeführt, die in den meisten ESP32-Boards vorbelegt sind:
| SPI-Schnittstelle | RAUCH | MISO | SCLK | CS |
| VSPI | GPIO23 | GPIO 19 | GPIO 18 | GPIO5 |
| HSPI | GPIO 13 | GPIO 12 | GPIO 14 | GPIO 15 |
Die oben genannten SPI-Pins können je nach Platinentyp variieren. Jetzt schreiben wir einen Code, um ESP32-SPI-Pins mit Arduino IDE zu überprüfen.
So finden Sie ESP32-Standard-SPI-Pins
Der unten geschriebene Code hilft, die Standard-SPI-Pins in der ESP32-Karte zu finden. Öffnen Sie die Arduino IDE, verbinden Sie ESP32 mit dem PC, wählen Sie den richtigen Port aus und laden Sie den Code hoch. Dann auf die Ausgabe warten. Das ist es! so einfach ist es
Code zum Finden von ESP32-Standard-SPI-Pins
Der unten angegebene Code druckt die ESP32-Standard-SPI-Pins auf dem seriellen Monitor.
ungültige Einrichtung ( ) {Serial.begin ( 115200 ) ;
Serial.print ( 'MOSI-GPIO-Pin: ' ) ;
Serial.println ( RAUCH ) ;
Serial.print ( 'MISO-GPIO-Pin: ' ) ;
Serial.println ( MISO ) ;
Serial.print ( 'SCK-GPIO-Pin: ' ) ;
Serial.println ( SCK ) ;
Serial.print ( 'SS-GPIO-Pin: ' ) ;
Serial.println ( SS ) ;
}
Leere Schleife ( ) {
}
Der Code beginnt mit der Definition der Baudrate und fährt mit dem Aufruf des Standard-GPIO-Pins für das ESP32-SPI-Kommunikationsprotokoll fort.
Ausgabe
Hier in unserem Fall zeigte der serielle Monitor die Pins 23, 19, 18 und 5 für MOSI, MISO, SCK bzw. SS an.
So verwenden Sie benutzerdefinierte SPI-Pins in ESP32
Dank der ESP32-Multiplexing-Funktionen ist es möglich, jeden Pin der ESP32-Karte als UART, I2C, SPI und PWM zu konfigurieren. Man muss sie nur im Code zuweisen. Jetzt werden wir neue SPI-Pins definieren und sie zur Bestätigung auf dem seriellen Monitor drucken.
Geben Sie den unten angegebenen Code in den Arduino IDE-Editor ein.
#includeungültige Einrichtung ( ) {
Serial.begin ( 115200 ) ;
Serial.print ( 'Standard-MOSI-GPIO-Pin: ' ) ;
Serial.println ( RAUCH ) ;
Serial.print ( 'Standard-MISO-GPIO-Pin: ' ) ;
Serial.println ( MISO ) ;
Serial.print ( 'Standard-SCK-GPIO-Pin: ' ) ;
Serial.println ( SCK ) ;
Serial.print ( 'Standard-SS-GPIO-Pin: ' ) ;
Serial.println ( SS ) ;
#definiere SCK 25
#definiere MISO 32
#define MOSI 26
#define CS 33
/* Library_Name Sensor_name ( CS, MOSI, MISO, SCK ) ; // Rufen Sie neue SPI-Pins auf */
Serial.print ( 'MOSI NEUER GPIO-Pin: ' ) ;
Serial.println ( RAUCH ) ;
Serial.print ( 'MISO NEUER GPIO-Pin: ' ) ;
Serial.println ( MISO ) ;
Serial.print ( 'SCK NEUER GPIO-Pin: ' ) ;
Serial.println ( SCK ) ;
Serial.print ( 'SS NEUER GPIO-Pin: ' ) ;
Serial.println ( SS ) ;
}
Leere Schleife ( ) {
}
Hier im obigen Code schließen wir die serielle SPI-Bibliothek ein und drucken dann die Standard-SPI-Pins auf dem seriellen Monitor. Man kann diesen Teil des Codes überspringen, wenn er nicht benötigt wird. Als nächstes weisen wir SPI mit der Definition neue Pins zu und drucken sie nacheinander auf dem seriellen Monitor.
Ausgabe
Die auf dem seriellen Monitor angezeigte Ausgabe druckt alle neuen SPI-Pins für die ESP32-Karte.
ESP32 mit mehreren SPI-Geräten
ESP32 hat zwei SPI-Busse und jeder Bus kann steuern 3 Geräte, was bedeutet, dass insgesamt 6 Geräte mit SPI von ESP32 gesteuert werden können. Um mehr Geräte zu steuern, können wir verschiedene Multiplexing-Techniken verwenden.
Während die Steuerung mehrerer Slave-Geräte ESP32 als Master für alle drei MISO-Leitungen fungiert, ist MOSI SCLK für sie gleich, der einzige Unterschied ist die CS-Taktsignalleitung. Um Daten an ein Slave-Gerät zu senden, sollte der CS-Pin dieses Slave-Geräts auf Low gesetzt werden.
Die folgende Syntax wird befolgt, wenn wir CS auf LOW setzen wollen.
Angenommen, wir möchten Daten von einem anderen Gerät lesen, also müssen wir den CS-Pin des ersten Slave-Geräts auf HIGH setzen, um es zu deaktivieren.
digitalWrite ( CS_2, NIEDRIG ) ; // Aktivieren Sie den CS-Pin von SLAVE zwei
Fazit
Die serielle Peripherieschnittstelle ist ein kabelgebundenes Kommunikationsprotokoll, das vom ESP32-Mikrocontroller verwendet wird, um Daten zwischen mehreren Slave-Geräten auszutauschen. ESP32 SPI unterstützt zwei verschiedene Busse für die Kommunikation, wobei jeder Bus 3 Slave-Geräte steuern kann. Standardmäßig wird ESP32 mit SPI-Pins geliefert; Wir können jedoch auch benutzerdefinierte Pins mithilfe von Code definieren und verwenden.