Maîtriser la communication série avec Arduino
Lorsque l’on travaille sur de gros projets Arduino, il est assez fréquent de se retrouver à court de broches disponibles pour brancher 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 de faire de la magie, il est parfois difficile de gérer toutes ces connexions sur une seule carte Arduino – en particulier lorsque vous décidez d’utiliser des cartes plus petites parce que vous êtes pressé par l’espace. C’est alors que la communication série entre en jeu.
Explorons ce qu’est la communication série et les façons dont vous pouvez la mettre en place 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 ou plusieurs appareils électroniques, un bit à la fois sur une seule ligne de communication. Comme son nom l’indique, les données sont envoyées en « série ».« .
Le simple fait de pouvoir télécharger des esquisses sur votre carte Arduino préférée utilise la communication série via USB.
Protocoles de communication série sur Arduino
Les cartes Arduino sont incroyablement polyvalentes et peuvent communiquer avec un large éventail de dispositifs. Elles 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 le fonctionnement des communications série UART, SPI et I2C.
Ce tutoriel utilise des croquis de base pour montrer comment vous pouvez établir 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 à grande vitesse 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 de l’esclave).
Le SPI.h est très pratique pour ce type de communication et doit être incluse en tête de votre esquisse.
Voici les broches SPI sur la carte Arduino Uno :
MOS | 11 | 4 |
MISO | 12 | 1 |
SCK | 13 | 3 |
SS | 10 (par défaut) | 1 (alternative) |
Après avoir initialisé la communication série, vous devrez configurer les broches de communication.
Le signal SS est utilisé pour indiquer au dispositif esclave que des données sont en cours de transfert.
Voici comment connecter deux cartes Arduino à l’aide de SPI.
Code pour la carte maître :
Code pour la carte esclave :
Veillez à ce que vos appareils partagent une masse commune pour une configuration correcte.
UART (récepteur-émetteur asynchrone universel)
UART est un protocole de communication série asynchrone qui permet la communication entre les appareils en utilisant seulement deux fils : TX (transmission) et RX (réception). L’UART est couramment utilisé pour communiquer avec des dispositifs tels que les modules GPS, les 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 les plus courantes sont les suivantes :
Uno, Nano, Mini | 0 (RX), 1 (TX) | N/A | N/A | N/D |
Mega | 0 (RX), 1 (TX) | 19 (RX), 18 (TX) | 17 (RX), 16 (TX) | 15 (RX), 14 (TX) |
Vous pouvez obtenir le tableau complet à l’adresse suivante la documentation en ligne d’Arduino sur la communication série.
Commencez par connecter vos cartes comme suit :
Ensuite, utilisez ce code pour la carte de l’expéditeur :
Code pour la carte réceptrice :
L’Arduino Uno fonctionne sur un niveau logique de 5V alors que le port RS232 d’un ordinateur utilise un niveau logique de +/-12V.
La connexion directe d’un Arduino Uno à un port RS232 peut endommager et endommagera votre carte.
I2C (circuit intégré)
I2C est un protocole de communication série synchrone qui permet la communication entre plusieurs appareils en utilisant seulement deux fils : SDA (données série) et SCL (horloge série). L’I2C est couramment utilisé pour la communication avec des capteurs, des EEPROM et d’autres dispositifs qui doivent transférer des données sur de courtes distances.
Les broches I2C de l’Arduino Uno sont les suivantes 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 tout d’abord, connectez vos cartes comme suit :
Code pour la carte maître :
Code pour la carte esclave :
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 à travers n’importe quelles deux broches numériques sur les cartes Arduino. Elle est utile lorsque l’UART matériel est déjà utilisé par d’autres périphériques.
Pour configurer SoftwareSerial, il faut d’abord inclure la bibliothèque SoftwareSerial dans le sketch.
Créez ensuite une instance de l’objet SoftwareSerial en spécifiant le paramètre RX et TX à utiliser pour la communication.
Voici un exemple de code pour Arduino qui démontre l’utilisation de SoftwareSerial :
La bibliothèque série
La bibliothèque Serial est un outil puissant dans Arduino qui permet la communication entre le microcontrôleur et un ordinateur ou d’autres appareils via une connexion série. Parmi les fonctions courantes, on peut citer :
Serial.begin(speed) | Initialise la communication série avec un débit de données spécifié. |
Serial.print(data) | Envoie des données au port série pour transmission sous forme de texte ASCII. |
Serial.write(data) | Envoie des données binaires brutes sur le port série. |
Serial.available() | Renvoie le nombre d’octets disponibles pour la lecture dans la mémoire tampon série. |
Serial.flush() | Attend la fin de la transmission des données série sortantes avant de poursuivre. |
Serial.read() | Lit le premier octet des données série entrantes et le renvoie sous la forme d’un entier. |
Débit en bauds et format des données série
Le débit en bauds fait référence à la vitesse à laquelle les données sont transférées sur la connexion série. Il représente le nombre de bits transmis par seconde. Le débit en bauds doit être réglé de la même manière sur les appareils émetteur et récepteur, sinon la communication risque d’être brouillée ou de ne pas fonctionner du tout. Les vitesses de transmission courantes pour Arduino sont 9600, 19200, 38400 et 115200.
Le format des données série fait référence à la structure des données envoyées par la connexion série. Il y a trois composants principaux au format de données série : les bits de départ, 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 optionnel utilisé pour le contrôle des erreurs. Il peut être réglé sur une parité nulle, paire ou impaire, en fonction des 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 de données doit être le même sur l’appareil émetteur et sur l’appareil récepteur pour garantir une communication correcte. Voici un exemple de la manière dont vous pouvez définir des formats de données spécifiques :
Ici, SERIAL_8N1 représente le format de données avec 8 bits de données, pas de parité et 1 bit d’arrêt. D’autres options telles que SERIAL_7E1, SERIAL_8O2 etc., peuvent être utilisés en fonction des exigences spécifiques du projet.
Parler 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 périphériques. En comprenant comment configurer les 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.
S’abonner à notre lettre d’information
Comment communiquer avec Arduino via le port série ?
Vous pouvez utiliser le moniteur série intégré à l’environnement Arduino pour communiquer avec une carte Arduino. Cliquez sur le bouton du moniteur série dans la barre d’outils et sélectionnez le même débit en bauds que celui utilisé dans l’appel à begin() . La communication série sur les broches TX/RX utilise des niveaux logiques TTL (5V ou 3,3V selon la carte).
Quels sont les 2 types de communication série dans Arduino ?
Types de communication série. Synchrone – Les périphériques qui sont synchronisés utilisent la même horloge et leur timing est synchronisé entre eux.Asynchrone – Les périphériques qui sont asynchrones ont leurs propres horloges et sont déclenchés par la sortie de l’état précédent.
- Synchrone – Les appareils qui sont synchronisés utilisent la même horloge et leur timing est synchronisé entre eux.
- Asynchrone – Les dispositifs qui sont asynchrones ont leurs propres horloges et sont déclenchés par la sortie de l’état précédent.
Quel est le protocole série utilisé par Arduino ?
Le protocole I2C implique l’utilisation de deux lignes pour envoyer et recevoir des données : une broche d’horloge série (SCL) que la carte contrôleur Arduino impulse à intervalle régulier, et une broche de données série (SDA) sur laquelle les données sont envoyées entre les deux appareils.
Que signifie « serial begin 9600 » ?
Serial. begin(9600) ; transmet la valeur 9600 au paramètre de vitesse. Cela indique à l’Arduino de se préparer à échanger des messages avec le moniteur série à un débit de données de 9600 bits par seconde. Il s’agit de 9600 binaires uns ou zéros par seconde, ce qui est communément appelé un débit en bauds.
