Les cartes ESP32 prennent en charge plusieurs protocoles de communication. Ces protocoles incluent série USART, I2C (IIC) et SPI. Parallèlement à ces cartes ESP32, des protocoles de communication sans fil sont également disponibles, tels que WiFi, double Bluetooth, ESP-Now, LoRa et bien d'autres. Aujourd'hui, nous allons nous concentrer sur le protocole ESP32 SPI (Serial Peripheral interface).
SPI (interface périphérique série) dans ESP32
SPI ou interface périphérique série est un protocole de communication à courte distance utilisé dans plusieurs dispositifs à microcontrôleur tels que ESP32. Il s'agit d'un protocole de communication synchrone principalement utilisé par les microcontrôleurs pour communiquer avec ses périphériques, de sorte que nous pouvons utiliser ce protocole pour lire et contrôler les appareils prenant en charge le protocole SPI.
La communication SPI prend en charge la configuration maître-esclave il y a toujours un une Maître qui contrôle plusieurs esclaves. C'est un Un duplex plein communication afin que les données puissent être échangées simultanément de maître à esclave et d'esclave à maître.
La communication SPI dans ESP32 a besoin quatre différentes broches pour transmettre et recevoir des données aux appareils. Voici ces quatre broches :
- SCK : La ligne d'horloge détermine la vitesse de transmission
- MISO: Master in slave out est la broche de transmission de l'esclave au maître
- FUMÉE: Master out slave in est la ligne de transmission des données maître vers l'esclave
- SS : La ligne de sélection d'esclave aide ESP32 à sélectionner un esclave particulier et à transmettre ou recevoir des données de cet esclave
Noter: Certains appareils qui sont uniquement esclaves et ne peuvent pas agir en tant que maître, leur nom de broche est différent, par exemple :
-
- MISO est remplacé par ODD (Sortie de données série)
- FUMÉE est remplacé par IDS (Entrée données série)
Broches SPI dans ESP32
La carte ESP32 est livrée avec 4 différents périphériques SPI intégrés à son microcontrôleur.
-
- SPI0 : Pour la communication de la mémoire interne uniquement - ne peut pas être utilisé avec des appareils SPI externes
- SPI1 : Pour la communication de la mémoire interne uniquement - ne peut pas être utilisé avec des appareils SPI externes
- SPI2 : (HSPI) ont des signaux de bus indépendants. Chaque bus peut dériver 3 appareils esclaves
- SPI3 : Le signal de bus (VSPI) est indépendant. Chaque bus peut dériver 3 appareils esclaves
La plupart des cartes ESP32 sont livrées avec des broches SPI préassignées pour SPI2 et SPI3. Cependant, s'ils ne sont pas attribués, nous pouvons toujours attribuer des broches SPI dans le code. Voici les broches SPI trouvées dans la plupart des cartes ESP32 qui sont préaffectées :
| Interface SPI | FUMÉE | MISO | SCLK | CS |
| VSPI | GPIO 23 | GPIO 19 | GPIO 18 | GPIO 5 |
| HSPI | GPIO 13 | GPIO 12 | GPIO 14 | GPIO 15 |
Les broches SPI mentionnées ci-dessus peuvent varier en fonction du type de carte. Nous allons maintenant écrire un code pour vérifier les broches ESP32 SPI à l'aide de l'IDE Arduino.
Comment trouver les broches SPI par défaut ESP32
Le code écrit ci-dessous aidera à trouver les broches SPI par défaut dans la carte ESP32. Ouvrez l'IDE Arduino, connectez ESP32 au PC, sélectionnez le bon port et téléchargez le code. Attendez ensuite la sortie. C'est ça! c'est aussi simple que ça
Code pour trouver les broches SPI par défaut ESP32
Le code ci-dessous imprimera les broches SPI par défaut ESP32 sur le moniteur série.
void setup ( ) {Serial.begin ( 115200 ) ;
Serial.print ( 'Broche GPIO MOSI : ' ) ;
Serial.println ( FUMÉE ) ;
Serial.print ( 'Broche GPIO MISO : ' ) ;
Serial.println ( MISO ) ;
Serial.print ( 'Broche GPIO SCK : ' ) ;
Serial.println ( SCK ) ;
Serial.print ( ' Broche SS GPIO : ' ) ;
Serial.println ( SS ) ;
}
boucle vide ( ) {
}
Le code commence par définir le débit en bauds et continue en appelant la broche GPIO par défaut pour le protocole de communication ESP32 SPI.
Production
Ici, dans notre cas, le moniteur série a affiché les broches 23, 19, 18 et 5 pour MOSI, MISO, SCK et SS respectivement.
Comment utiliser les broches SPI personnalisées dans ESP32
Grâce aux fonctionnalités de multiplexage ESP32, il est possible de configurer n'importe quelle broche de la carte ESP32 comme UART, I2C, SPI et PWM. Il suffit de les affecter dans le code. Nous allons maintenant définir de nouvelles broches SPI et les imprimer sur le moniteur série pour confirmer.
Tapez le code ci-dessous dans l'éditeur IDE Arduino.
#includevoid setup ( ) {
Serial.begin ( 115200 ) ;
Serial.print ( 'Broche MOSI GPIO par défaut : ' ) ;
Serial.println ( FUMÉE ) ;
Serial.print ( 'Broche MISO GPIO par défaut : ' ) ;
Serial.println ( MISO ) ;
Serial.print ( 'Broche GPIO SCK par défaut : ' ) ;
Serial.println ( SCK ) ;
Serial.print ( « Broche SS GPIO par défaut : » ) ;
Serial.println ( SS ) ;
#définir SCK 25
#définir MISO 32
#définir MOSI 26
#définir CS 33
/* Library_Name Sensor_name ( CS, MOSI, MISO, SCK ) ; // appeler de nouvelles broches SPI */
Serial.print ( 'MOSI NOUVELLE Broche GPIO : ' ) ;
Serial.println ( FUMÉE ) ;
Serial.print ( 'MISO NOUVELLE broche GPIO : ' ) ;
Serial.println ( MISO ) ;
Serial.print ( 'SCK NOUVELLE Broche GPIO : ' ) ;
Serial.println ( SCK ) ;
Serial.print ( ' SS NOUVELLE Broche GPIO : ' ) ;
Serial.println ( SS ) ;
}
boucle vide ( ) {
}
Ici, dans le code ci-dessus, nous incluons la bibliothèque série SPI, puis imprimons les broches SPI par défaut sur le moniteur série. On peut ignorer cette partie du code si ce n'est pas nécessaire. Ensuite, en utilisant la définition, nous attribuons de nouvelles broches à SPI et les imprimons une par une sur le moniteur série.
Production
La sortie affichée sur le moniteur série imprime toutes les nouvelles broches SPI pour la carte ESP32.
ESP32 avec plusieurs appareils SPI
ESP32 a deux bus SPI, et chaque bus peut contrôler 3 appareils, ce qui signifie qu'un total de 6 appareils peuvent être contrôlés à l'aide du SPI d'ESP32. Pour contrôler plus d'appareils, nous pouvons utiliser différentes techniques de multiplexage.
Tout en contrôlant plusieurs appareils esclaves, ESP32 agira en tant que maître pour les trois lignes MISO, MOSI SCLK sera le même pour eux, la seule différence est la ligne de signal d'horloge CS. Pour envoyer des données à un appareil esclave, la broche CS de cet appareil esclave doit être réglée sur bas.
La syntaxe suivante sera suivie si nous voulons définir CS sur LOW.
Supposons que nous voulions lire les données de n'importe quel autre appareil, nous devons donc définir la broche CS du premier appareil esclave sur HIGH pour le désactiver.
numériqueÉcrire ( CS_2, FAIBLE ) ; // Activer la broche CS de SLAVE deux
Conclusion
L'interface périphérique série est un protocole de communication filaire utilisé par le microcontrôleur ESP32 pour échanger des données entre plusieurs appareils esclaves. ESP32 SPI prend en charge deux bus différents pour la communication avec chaque capacité de bus de contrôler 3 appareils esclaves. Par défaut, ESP32 est livré avec des broches SPI ; cependant, nous pouvons également définir et utiliser des broches personnalisées à l'aide de code.