Maîtriser la communication série avec Arduino

Lorsque vous travaillez sur de grands projets Arduino, il est assez courant de manquer de broches disponibles pour connecter des composants. Supposons que vous souhaitiez connecter plusieurs capteurs/actionneurs avec le besoin urgent de conserver des broches supplémentaires pour alimenter un module d'affichage gourmand en broches.

À moins que vous ne fassiez de la magie, il est parfois difficile de gérer toutes ces connexions sur une seule carte Arduino, surtout lorsque vous décidez d'utiliser des cartes plus petites parce que vous manquez d'espace. C'est alors que la communication série entre en jeu.

Explorons ce qu'est la communication série et comment vous pouvez la configurer avec Arduino pour des tâches telles que le traitement distribué et l'intégration générale.

Qu'est-ce que la communication série?

La communication série est une méthode d'envoi et de réception de données entre deux appareils électroniques ou plus, un bit à la fois sur une seule ligne de communication. Comme son nom l'indique, les données sont envoyées en "séries

".

Même le simple fait de pouvoir télécharger des croquis sur votre carte Arduino préférée utilise une communication série via USB.

Protocoles de communication série sur Arduino

Les cartes Arduino sont incroyablement polyvalentes et peuvent communiquer avec une large gamme d'appareils. Ils prennent en charge quatre protocoles de communication série: Soft Serial, SPI (Serial Peripheral Interface), UART standard (Universal Asynchronous Receiver-Transmitter) et I2C (Inter-Integrated Circuit). Pour plus de détails, consultez notre guide complet sur comment fonctionnent les communications série UART, SPI et I2C.

Ce didacticiel utilise des croquis de base pour montrer comment configurer une connexion série entre deux cartes Arduino Uno à l'aide de différents protocoles. Adaptez le code pour répondre à vos besoins spécifiques.

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

SPI est un protocole de communication série synchrone qui permet une communication à haut débit entre les microcontrôleurs et les périphériques. Ce protocole nécessite quatre fils pour la communication: SCK (horloge série), MOSI (Master Out Slave In), MISO (Master In Slave Out), et SS (Sélection esclave).

Le SPI.h La bibliothèque est très pratique pour ce type de communication et doit être incluse en haut de votre croquis.

#inclure

Voici les broches SPI sur la carte Arduino Uno :

Après avoir initialisé la communication série, vous devrez configurer les broches de communication.

annulerinstallation(){
IPS.commencer(115200);
// Définir les modes de broche pour SS, MOSI, MISO et SCK
PinMode(SS, SORTIR);
PinMode(MOSI, SORTIR);
PinMode(MISO, SAISIR);
PinMode(SCK, SORTIR);
// Définissez la broche de sélection esclave (SS) haute pour désactiver le périphérique esclave
numériqueÉcrire(SS, HAUT);
}

Le signal SS est utilisé pour indiquer à l'appareil esclave que les données sont en cours de transfert.

// Sélectionne l'esclave
numériqueÉcrire(SS, FAIBLE);
// Envoie les données au périphérique esclave
IPS.transfert(données);
// Désélectionne le périphérique esclave
numériqueÉcrire(SS, HAUT);

Voici comment connecter deux cartes Arduino à l'aide de SPI.

Code pour la carte maître :

#inclure
constanteentier esclaveSelectPin = 10;
annulerinstallation(){
IPS.commencer(115200);
PinMode(slaveSelectPin, SORTIR);
}
annulerboucle(){
numériqueÉcrire(slaveSelectPin, FAIBLE);
IPS.transfert('H');
numériqueÉcrire(slaveSelectPin, HAUT);
retard(1000);
}

Code de la carte esclave :

#inclure
constanteentier esclaveSelectPin = 10;
annulerinstallation(){
IPS.commencer(115200);
PinMode(slaveSelectPin, SORTIR);
}
annulerboucle(){
si (numériqueLire(slaveSelectPin) == FAIBLE) {
carboniser Données reçues = IPS.transfert('L');
En série.println(donnéesreçues);
 }
}

Assurez-vous que vos appareils partagent une base commune pour une configuration correcte.

UART (Universal Asynchronous Receiver-Transmitter)

UART est un protocole de communication série asynchrone qui permet la communication entre des appareils en utilisant seulement deux fils: TX (transmission) et RX (réception). UART est couramment utilisé pour la communication avec des appareils tels que des modules GPS, des modules Bluetooth et d'autres microcontrôleurs. Chaque carte Arduino est équipée d'au moins un port pour UART.

Les broches UART sur les cartes Arduino populaires incluent :

Vous pouvez obtenir le tableau complet à partir de Documentation en ligne d'Arduino sur la communication série.

Tout d'abord, connectez vos cartes comme ceci :

Utilisez ensuite ce code pour la carte émettrice :

annulerinstallation(){
En série.commencer(9600);
}
annulerboucle(){
// Envoie un message en série toutes les secondes
En série.println("Bonjour du tableau des expéditeurs !");
retard(1000);
}

Code de la carte réceptrice :

annulerinstallation(){
En série.commencer(9600);
}
annulerboucle(){
// Vérifie s'il y a des données entrantes
si (En série.disponible() > 0) {
// Lire les données entrantes et les imprimer sur le moniteur série
Chaîne données entrantes = En série.readString();
En série.println(incomingData);
 }
}

L'Arduino Uno fonctionne sur un niveau logique de 5V tandis que le port RS232 d'un ordinateur utilise un niveau logique de +/-12V.

Connecter directement un Arduino Uno à un port RS232 peut et endommagera votre carte.

I2C (circuit inter-intégré)

I2C est un protocole de communication série synchrone qui permet la communication entre plusieurs appareils en utilisant seulement deux fils: SDA (Serial Data) et SCL (Serial Clock). I2C est couramment utilisé pour la communication avec des capteurs, des EEPROM et d'autres appareils qui doivent transférer des données sur de courtes distances.

Les broches I2C de l'Arduino Uno sont SDA (A4) et SCL (A5).

Nous allons créer un programme simple pour établir une connexion entre deux cartes Arduino en utilisant la communication I2C. Mais d'abord, connectez vos cartes comme ceci :

Code pour la carte maître :

#inclure
annulerinstallation(){
Fil.commencer(); // rejoindre le bus I2C en tant que maître
En série.commencer(9600);
}
annulerboucle(){
Fil.commencer la transmission(9); // transmettre à l'appareil esclave avec l'adresse 9
Fil.écrire('un'); // envoie 'a' octet au périphérique esclave
Fil.finTransmission(); // arrête de transmettre
retard(500);
}

Code de la carte esclave :

#inclure
annulerinstallation(){
Fil.commencer(9); // rejoindre le bus I2C en tant qu'esclave avec l'adresse 9
Fil.à la réception(recevoirEvénement);
En série.commencer(9600); 
}
annulerboucle(){
retard(100);
}
annulerrecevoirEvénement(entier octets){
alors que(Fil.disponible()) { // boucle sur tous les octets reçus
carboniser octet reçu = Fil.lire(); // lit chaque octet reçu
En série.println(receivedByte); // affiche l'octet reçu sur le moniteur série
 }
}

Qu'est-ce que SoftwareSerial?

La bibliothèque Arduino SoftwareSerial a été développée pour émuler la communication UART, permettant une communication série via deux broches numériques quelconques sur les cartes Arduino. C'est utile lorsque l'UART matériel est déjà utilisé par d'autres appareils.

Pour configurer SoftwareSerial, incluez d'abord la bibliothèque SoftwareSerial dans l'esquisse.

#inclure

Créez ensuite une instance de l'objet SoftwareSerial en spécifiant le RX et TX broches à utiliser pour la communication.

LogicielSerialmySerial(2, 3); // Broches RX, TX

Voici un exemple de code pour Arduino qui illustre l'utilisation de SoftwareSerial :

#inclure
LogicielSerialmySerial(2, 3); // Broches RX, TX
annulerinstallation(){
En série.commencer(9600); // démarre la série matérielle
 monSérie.commencer(9600); // démarre la série logicielle
}
annulerboucle(){
si (monSérie.disponible()) {
En série.écrire(monSérie.lire()); // envoie les données reçues au matériel série
 }
si (En série.disponible()) {
 monSérie.écrire(En série.lire()); // envoie les données de la série matérielle à la série logicielle
 }
}

La bibliothèque en série

La bibliothèque série est un outil puissant d'Arduino qui permet la communication entre le microcontrôleur et un ordinateur ou d'autres appareils via une connexion série. Certaines fonctions courantes incluent :

Débit en bauds et format de données série

Le débit en bauds fait référence à la vitesse à laquelle les données sont transférées via la connexion série. Il représente le nombre de bits transmis par seconde. Le débit en bauds doit être identique sur les appareils émetteur et récepteur, sinon la communication peut être brouillée ou ne pas fonctionner du tout. Les débits en bauds courants pour Arduino incluent 9600, 19200, 38400 et 115200.

Le format de données série fait référence à la structure des données envoyées via la connexion série. Le format de données série comporte trois composants principaux: les bits de démarrage, les bits de données et les bits d'arrêt.

• Bits de données: Le nombre de bits utilisés pour représenter un seul octet de données.
• Parité: Un bit facultatif utilisé pour la vérification des erreurs. Elle peut être réglée sur aucune, paire ou impaire, selon les exigences du canal de communication.
• Bits d'arrêt: Le nombre de bits utilisés pour signaler la fin d'un octet de données.

Le format des données doit être le même sur les appareils de transmission et de réception pour assurer une communication correcte. Voici un exemple de la manière dont vous pouvez définir des formats de données spécifiques :

annulerinstallation(){
// Configurez la communication série avec un débit de 9600 bauds, 8 bits de données, pas de parité et 1 bit d'arrêt
En série.commencer(9600, SÉRIE_8N1); 
}

Ici, SÉRIE_8N1 représente le format de données avec 8 bits de données, pas de parité, et 1 peu d'arrêt. D'autres options telles que SÉRIE_7E1, SÉRIE_8O2, etc., peuvent être utilisés en fonction des exigences spécifiques du projet.

Conversation en série

Les cartes Arduino offrent diverses options de communication série qui permettent un échange de données efficace et fiable entre les appareils. En comprenant comment configurer des protocoles de communication série sur l'IDE Arduino, vous pouvez tirer parti de la puissance du traitement distribué ou réduire considérablement le nombre de fils utilisés dans vos projets.