Communication Série Raspberry Pi Arduino – Tout Ce que Vous Devez Savoir

BY admin
|

Dans ce tutoriel, je vais vous montrer comment communiquer entre un Raspberry Pi et une carte Arduino via une communication Série.

Tout d’abord, je vais rapidement expliquer ce qu’est la communication série. Ensuite, vous verrez comment configurer votre matériel et vos logiciels, et nous plongerons dans le code Python (Cpp pour Arduino). Un exemple de base au début, conduisant à une application plus complète utilisant un Raspberry Pi, un Arduino et d’autres appareils électroniques.

Ce tutoriel fonctionnera avec une carte Raspberry Pi 4 (et versions antérieures: 3B, 3B+) et n’importe quelle carte Arduino. J’utiliserai principalement Arduino Uno mais je donnerai plus de détails sur les différences entre les cartes Arduino en matière de communication série.

Lorsque vous travaillez avec des appareils électroniques, la communication est essentielle. Chaque appareil – en plus de bien faire ce qu’il est censé faire – doit pouvoir communiquer clairement avec d’autres appareils. C’est l’une des choses les plus importantes à travailler pour passer d’une application très basique à des applications plus complexes.

Table des Matières

Qu’est-ce que la communication série (avec UART)

La communication série est simplement un moyen de transférer des données. Les données seront envoyées séquentiellement, un bit à la fois (1 octet = 8 bits), contrairement à la communication parallèle, où plusieurs bits sont envoyés en même temps.

Protocole UART

Plus précisément, lorsque vous utilisez Serial avec Arduino et Raspberry Pi, vous utilisez le protocole UART. UART signifie « Réception et Transmission Asynchrones Universelles ».

Vous apprenez à utiliser Raspberry Pi pour construire vos propres projets?

Découvrez Raspberry Pi pour les débutants et apprenez étape par étape.

Fondamentalement, c’est un protocole multi-maître asynchrone basé sur la communication série, qui vous permettra de communiquer entre les 2 cartes. Rassurez-vous, il existe des bibliothèques qui géreront toutes les couches basses pour vous.

Multi-maître signifie que tous les appareils connectés seront libres d’envoyer des données quand ils le souhaitent. C’est l’une des principales différences avec les protocoles maîtres-esclaves, où seul le périphérique maître peut initier une communication. Habituellement, vous utiliserez d’autres protocoles tels que I2C et SPI lorsque vous avez besoin de configurations maître-esclave: par exemple lorsque vous avez une carte Arduino et plusieurs capteurs ou actionneurs.

La carte Arduino Uno possède un UART que vous pouvez utiliser soit avec un câble USB, soit à partir des broches RX/TX (ne l’utilisez pas avec les deux en même temps). Certaines cartes ont plus d’UARTs disponibles. Par exemple, l’Arduino Mega a différentes séries (Serial, Serial1, Serial2, Serial3) et l’Arduino Zero a un port USB natif uniquement (utilisez SerialUSB au lieu de Serial).

Sur le Raspberry Pi, vous pouvez connecter de nombreux périphériques série sur les ports USB. Chacun aura un nom d’appareil différent (nous verrons comment les trouver plus tard dans ce tutoriel). Vous pouvez également utiliser les GPIO (RX0/TX0) pour un UART supplémentaire.

Vous connaissez probablement déjà la communication série

Vous avez certainement déjà utilisé la communication série plusieurs fois. Je suis sûr que vous connaissez déjà la bibliothèque série Arduino, qui vous permet de consigner ce qui se passe dans votre code et d’obtenir l’entrée de l’utilisateur. Lorsque vous utilisez le moniteur série, eh bien, en gros, votre Arduino Arduino initie une communication série avec votre Arduino. Vous pouvez recevoir et envoyer des données directement depuis le moniteur série.

Ce que nous allons faire ici est presque le même, sauf qu’au lieu de votre Arduino Arduino, l’autre côté de la communication série sera une carte Raspberry Pi. Nous devrons faire une configuration et écrire du code pour que cela fonctionne. Ensuite, le Raspberry Pi et l’Arduino pourront s’envoyer des messages.

Voyons maintenant comment connecter physiquement les 2 cartes ensemble.

Configuration matérielle pour la communication série

Il existe 2 façons de connecter votre Raspberry Pi et Arduino pour la communication série.

Série via USB

Le moyen le plus simple consiste à utiliser un câble USB entre les deux cartes.

Du côté du Raspberry Pi, un simple connecteur USB est tout ce dont vous avez besoin. Vous pouvez choisir l’un des 4 ports USB disponibles sur la carte.

Pour Arduino, vous utiliserez le port USB que vous utilisez pour télécharger le code de votre ordinateur (avec l’ Arduino Arduino) sur votre carte. Ici, le connecteur USB dépendra de la version que vous avez. Pour les cartes comme Arduino Uno et Mega, le connecteur sera différent d’Arduino Nano et d’Arduino Zero.

Pour cet exemple, j’ai utilisé une carte Arduino Uno.

Comme vous pouvez le voir, c’est la connexion matérielle la plus simple que vous puissiez établir entre Raspberry Pi et Arduino.

Remarque: vous devrez d’abord connecter votre Arduino à votre ordinateur, afin de pouvoir télécharger le code dans la carte. Après cela, connectez le câble USB au Raspberry Pi. Le Raspberry Pi alimentera l’Arduino via ce câble.

Série via GPIOs

Pour établir une connexion série, vous pouvez également utiliser des fils simples entre les GPIOs Raspberry Pi et les broches Arduino.

Selon votre carte Arduino, vous devrez peut-être utiliser un régulateur de niveau de tension. Le Raspberry Pi fonctionne à 3,3V. Pour les cartes Arduino comme Due, 101, ce sera bien car elles utilisent également 3,3V.

Mais, pour de nombreux Arduino, tels que Uno, Mega, Leonardo, Nano, et bien d’autres, la carte fonctionne à 5V. Ainsi, vous avez besoin d’un levier de niveau 3.3V / 5V pour protéger le Raspberry Pi lors de la connexion RX et TX (plus d’informations sur les broches Raspberry Pi et les broches Arduino Uno).

Pour la suite de ce tutoriel, nous utiliserons la configuration avec le câble USB. Ce sera plus facile à gérer et à moins d’avoir une bonne raison, vous devriez préférer utiliser le câble USB au lieu de gpio simples pour la communication série.

Configuration du logiciel Raspberry Pi

Vous n’avez besoin d’aucune configuration spéciale pour Arduino. Assurez-vous simplement d’avoir téléchargé et installé l’ Arduino Arduino.

Maintenant, sur votre Raspberry Pi, quelques éléments sont nécessaires pour que la communication fonctionne.

Connectez à votre Raspberry Pi, soit via ssh, soit par plugin un écran + souris + clavier, et ouvrez un terminal. Si vous n’avez pas encore installé de système d’exploitation sur votre Pi, vous pouvez installer Raspbian ou Ubuntu très facilement sur une carte SD.

Détecter la carte Arduino

Lorsque vous connectez l’Arduino avec un câble USB, vous devriez la voir apparaître sous la forme /dev/ttyACM0, ou /dev/ttyUSB0 (parfois le nombre peut être différent, par exemple /dev/ttyACM1).

Exécutez simplement ls /dev/tty* et vous devriez le voir. À ce stade, si vous ne savez pas quel appareil est la carte Arduino, déconnectez simplement la carte (retirez le câble USB) et exécutez à nouveau ls /dev/tty*. De cette façon, vous pourrez facilement repérer le nom du périphérique série de votre Arduino.

Autorisations matérielles pour Serial

De plus, vous pouvez ajouter votre utilisateur au groupe de numérotation pour éviter des erreurs telles que :serial.serialutil.SerialException: impossible d’ouvrir le port /dev/ttyACM0: Autorisation refusée: ‘/dev/ttyACM0’

$ sudo adduser your_username dialout

Cela vous permettra d’avoir accès aux périphériques série (/dev/ttyACMx, /dev/ttyUSBx, …).

Après vous être ajouté au groupe de déconnexion, vous devez redémarrer votre Pi (ou au moins vous déconnecter / vous connecter) pour appliquer la modification – en savoir plus sur les autorisations matérielles du Raspberry Pi.

Installer la bibliothèque série Python sur Raspberry Pi

Vous devez installer une bibliothèque pour pouvoir utiliser l’interface série avec Python.

Pour ce tutoriel, nous utiliserons la bibliothèque pySerial (documentation pour Python 3). Pour l’installer:

python3 -m pip install pyserial

Cette bibliothèque Python est bien connue et utilisée dans de nombreuses applications.

Lors de l’installation, si vous obtenez une erreur telle que « /usr/bin/python3: Aucun module nommé pip », vous devez d’abord installer pip avec sudo apt install python3-pip.

Communication série simple entre Arduino et Raspberry Pi

Commençons par un programme très simple.

Code Arduino

Téléchargez ce code depuis votre ordinateur sur votre Arduino, en utilisant l’E Arduino.

void setup() { Serial.begin(9600);}void loop() { Serial.println("Hello from Arduino!"); delay(1000);}

Tout d’abord, nous initialisons la communication série, et choisissons un débit en bauds, ici 9600. 9600 est un débit en bauds couramment utilisé, et également assez faible. Dans vos futures applications, vous pouvez utiliser un débit en bauds de 57600 ou même 115200 sans aucun problème. Pour ce tutoriel, nous allons continuer avec 9600.

Chaque seconde, nous faisons envoyer à l’Arduino une chaîne avec Serial.println(). la fonction println() ajoutera un caractère de saut de ligne ‘\n’ à la fin de la chaîne.

Vous pouvez ouvrir le moniteur série pour voir la chaîne sur votre ordinateur.

Code Python Raspberry Pi 

#!/usr/bin/env python3import serialif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: if ser.in_waiting > 0: line = ser.readline().decode('utf-8').rstrip() print(line)

Alors, que fait ce code?

#!/usr/bin/env python3import serial

Tout d’abord, nous importons la bibliothèque série que nous avons précédemment installée.

if __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)

La communication série est initialisée en appelant serial.Serial() avec quelques paramètres:

  • Nom du périphérique série pour l’Arduino: habituellement ‘/dev/ttyACM0’, ‘/dev/ttyUSB0’, ou similaire.
  • Vitesse de transmission : ce paramètre est très important. Vous devez utiliser la même vitesse de transmission que celle que vous avez utilisée sur Arduino, sinon tout ce que vous lirez et écrirez sera des ordures. Donc, nous choisissons 9600 comme nous l’avons fait dans l’esquisse Arduino.
  • délai d’attente : il s’agit d’un délai d’attente pour les opérations de lecture. Ici, nous l’avons réglé sur 1 seconde. Cela signifie que lorsque nous lisons à partir de Serial, le programme ne sera pas bloqué pour toujours si les données ne viennent pas. Après 1 seconde ou lecture, si tous les octets ne sont pas reçus, la fonction renverra les octets déjà reçus.

Donc, série.Serial() renvoie un objet que vous pouvez utiliser pour toutes vos opérations série. Nous le stockons dans la variable ‘ser’.

 ser.flush()

Ensuite, nous utilisons la fonction flush(). Cela videra tout tampon d’entrée et de sortie, ce qui évitera de recevoir ou d’envoyer des données étranges / non utiles / non complètes au début de la communication.

 while True: if ser.in_waiting > 0: line = ser.readline().decode('utf-8').rstrip() print(line)

Dans une boucle infinie (pensez à la fonction loop() dans l’esquisse Arduino), nous vérifions si certaines données sont disponibles avec l’attribut in_waiting (ne mettez pas de parenthèses, ce n’est pas une fonction). Si oui, nous pouvons lire les données.

La fonction readline() lira tous les octets jusqu’à ce qu’un caractère de saut de ligne soit détecté.

Si nous venions d’imprimer ce que nous avons reçu, nous verrions b’Hello d’Arduino!\r\n’. Vous recevez des octets lorsque vous lisez depuis Serial et vous devez convertir (décoder) ces octets dans le type de données approprié. Nous utilisons donc decode(‘utf-8’) – vous pouvez également utiliser decode(‘ascii’) – pour décoder les données reçues en une chaîne.

Enfin, la fonction rstrip() est spécifique aux chaînes, elle vous permet de supprimer les caractères de fin (saut de ligne, retour chariot). De cette façon, nous pouvons supprimer les ‘\r’ et ‘\n’ et obtenir une chaîne appropriée.

Remarque: ici, nous lisons une ligne complète à chaque fois. Si vous souhaitez lire un certain nombre d’octets – un ou plusieurs – utilisez la fonction read(size=1).

Test de la communication série

Maintenant, débranchez votre carte Arduino de votre ordinateur et connectez-la à votre carte Raspberry Pi.

Le code Arduino est déjà en cours d’exécution, dès qu’il est sous tension.

Sur le Raspberry Pi, rendez le fichier Python exécutable et lancez-le.

$ chmod +x receive_serial_data_from_arduino.py$ ./receive_serial_data_from_arduino.py Hello from Arduino!Hello from Arduino!Hello from Arduino!

Ça marche ! La chaîne envoyée par Arduino chaque seconde est affichée sur le terminal Raspberry Pi.

Communication série bidirectionnelle entre Raspberry Pi et Arduino

Rendons les choses un peu plus intéressantes. Vous avez vu comment envoyer des données d’Arduino à Raspberry Pi. Dans cette partie, vous verrez comment parler de Raspberry Pi à Arduino. Ainsi, vous aurez les deux côtés de la communication et vous pourrez créer des programmes qui attendent l’entrée de l’autre.

Code Arduino 

void setup() { Serial.begin(9600);}void loop() { if (Serial.available() > 0) { String data = Serial.readStringUntil('\n'); Serial.print("You sent me: "); Serial.println(data); }}

Ici, nous vérifions si l’Arduino a reçu des données en série.disponible(). Cela vous donnera le nombre d’octets déjà arrivés et stockés dans le tampon de réception.

Si certaines données sont arrivées, nous utilisons Serial.readStringUntil() avec un caractère de saut de ligne ‘\n’ pour obtenir la ligne suivante. Ceci est similaire à la fonction readline(). Tous les octets reçus jusqu’à ‘\n’ sont automatiquement convertis et ajoutés dans un objet Chaîne Arduino.

Ensuite, nous imprimons simplement les données que nous avons reçues, avec un morceau de texte supplémentaire.

Remarque: si vous souhaitez lire les octets un par un, vous pouvez le faire avec la série.fonction read(). Ensuite, vous devrez convertir ce (ces) octet (s) si nécessaire: int, String, etc.

Code Python Raspberry Pi 

#!/usr/bin/env python3import serialimport timeif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: ser.write(b"Hello from Raspberry Pi!\n") line = ser.readline().decode('utf-8').rstrip() print(line) time.sleep(1)

Utilisez la fonction pySerial write() pour envoyer des données à l’Arduino. Ici, vous pouvez voir que j’ai ajouté un ‘b’ avant la chaîne à envoyer. Cela encodera la chaîne en octets, car vous ne pouvez envoyer des octets que par série. Toutes les données qui ne sont pas un octet ou un tableau d’octets doivent être converties avant d’être envoyées. Si vous essayez simplement d’envoyer la chaîne comme ça, vous obtiendrez cette erreur « TypeError: les chaînes unicode ne sont pas prises en charge, veuillez encoder en octets: ‘Bonjour de Raspberry Pi!' »

Remarque: au lieu de ser.write(b"Hello from Raspberry Pi!\n"), vous auriez pu écrire ser.write("Hello from Raspberry Pi!\n".encode('utf-8')) ou ser.write("Hello from Raspberry Pi!\n".encode('ascii')). Cela fera la même chose. La fonction encode() prendra la chaîne et l’encodera en série.

De plus, nous ajoutons un caractère de nouvelle ligne ‘\n’ car c’est ce que l’Arduino devrait terminer sa lecture avec Serial.readStringUntil(‘\n’).

Ensuite, nous faisons la même chose qu’avant: nous lisons une ligne, la décodons en chaîne et supprimons tout caractère de fin. On n’utilise pas le ser.en attente ici, car pour cette application spécifique, nous savons que l’Arduino renverra des données juste après avoir reçu la chaîne. De plus, nous avons un délai d’attente de 1 seconde pour éviter d’être bloqués sur cette ligne.

Enfin, nous imprimons la chaîne reçue et attendons 1 seconde avec le temps.sleep() avant d’envoyer la chaîne suivante sur Serial.

Test de la communication série bidirectionnelle

Sur votre Raspberry Pi, rendez votre fichier Python exécutable et lancez-le.

$ chmod +x bidirectional_serial_communication.py $ ./bidirectional_serial_communication.py You sent me: Hello from Raspberry Pi!You sent me: Hello from Raspberry Pi!You sent me: Hello from Raspberry Pi!

Succès! L’Arduino a reçu la chaîne et l’a renvoyée avec quelques mots de plus. Ensuite, le Raspberry Pi a reçu et imprimé la chaîne finale.

Communication série Raspberry Pi Arduino: Exemple d’application

Maintenant que vous savez comment configurer votre Arduino et votre Raspberry Pi pour la communication série, et écrire des programmes pour parler entre chaque carte, créons une application plus complexe.

Dans cette application, 4 LED et un bouton poussoir seront connectés à la carte Arduino.

Le Raspberry Pi et l’Arduino seront connectés avec un câble USB et utiliseront la communication série pour se parler.

Voici le résultat que nous voulons obtenir:

  • Lorsque le bouton poussoir est enfoncé, l’Arduino enverra une notification au Raspberry Pi (un simple octet).
  • Le Raspberry Pi calculera alors un nombre entier aléatoire compris entre 1 et 4, et l’enverra à l’Arduino.
  • L’Arduino allumera la LED associée à ce numéro et éteindra les autres LED.

Cela vous fera pratiquer la communication et la synchronisation des tâches entre Arduino et Raspberry Pi.

Si vous êtes arrivé à ce stade du tutoriel (félicitations!) Je vous encourage à essayer d’écrire le code par vous-même avant de lire le code que j’ai fourni ci-dessous. De plus, il n’y a pas qu’un seul code possible pour répondre à ces exigences, donc votre code peut être différent du mien, c’est tout à fait CORRECT. Vous pouvez obtenir de l’aide de la référence série Arduino et de la référence API pySerial.

Schémas

Pour faire ce circuit:

  • Connectez 4 LED aux broches 9-12. Ajoutez une résistance de 220 Ohms pour chaque LED entre la jambe la plus longue et la broche numérique. La jambe la plus courte est reliée au sol.
  • Ajouter un bouton poussoir avec une résistance de 10kOhm connectée à la masse (résistance déroulante). Un côté du bouton est connecté à 5V, l’autre à la broche numérique 5 pour la lecture.
  • N’oubliez pas de faire un point commun entre tous les composants : la carte Arduino, les 4 LEDs et le bouton poussoir. N’ajoutez pas d’alimentation si vous n’avez pas au moins correctement connecté les motifs.
  • Connectez l’Arduino et le Raspberry Pi via un câble USB, pour la communication série (le câble USB gère déjà la connexion à la terre entre vos 2 cartes).

Code Arduino 

#define LED_1_PIN 9#define LED_2_PIN 10#define LED_3_PIN 11#define LED_4_PIN 12#define BUTTON_PIN 5byte lastButtonState = LOW;byte currentButtonState = LOW;unsigned long lastButtonDebounceTime = 0;unsigned long buttonDebounceDelay = 20;void powerOffAllLEDs(){ digitalWrite(LED_1_PIN, LOW); digitalWrite(LED_2_PIN, LOW); digitalWrite(LED_3_PIN, LOW); digitalWrite(LED_4_PIN, LOW);}void setup(){ Serial.begin(9600); pinMode(LED_1_PIN, OUTPUT); pinMode(LED_2_PIN, OUTPUT); pinMode(LED_3_PIN, OUTPUT); pinMode(LED_4_PIN, OUTPUT); pinMode(BUTTON_PIN, INPUT); powerOffAllLEDs();}void loop(){ byte readValue = digitalRead(BUTTON_PIN); if (readValue != lastButtonState) { lastButtonDebounceTime = millis(); } if (millis() - lastButtonDebounceTime > buttonDebounceDelay) { if (readValue != currentButtonState) { currentButtonState = readValue; if (currentButtonState == HIGH) { Serial.write(18); } } } lastButtonState = readValue; if (Serial.available() > 0) { int ledNumber = Serial.read() - '0'; powerOffAllLEDs(); switch (ledNumber) { case 1: digitalWrite(LED_1_PIN, HIGH); break; case 2: digitalWrite(LED_2_PIN, HIGH); break; case 3: digitalWrite(LED_3_PIN, HIGH); break; case 4: digitalWrite(LED_4_PIN, HIGH); break; default: // wrong pin number, do nothing // all LEDs will be powered off break; } }}

Dans la fonction setup(), nous initialisons les modes pin pour les 4 LED et le bouton poussoir. Nous nous assurons également que toutes les LED sont éteintes.

Ensuite, dans la boucle (), nous faisons 2 choses: gérer le bouton-poussoir et gérer les 4 LEDs. Les deux actions sont effectuées une par une, mais elles sont gérées très rapidement, c’est donc comme si elles se produisaient en même temps. C’est un cas de multitâche d’un programme Arduino.

Première action : manipulation du bouton poussoir.

byte readValue = digitalRead(BUTTON_PIN);if (readValue != lastButtonState) { lastButtonDebounceTime = millis();}if (millis() - lastButtonDebounceTime > buttonDebounceDelay) { if (readValue != currentButtonState) { currentButtonState = readValue; if (currentButtonState == HIGH) { Serial.write(18); } }}lastButtonState = readValue;

Nous devons démonter le bouton pour éviter les valeurs indésirables. Lorsque nous découvrons que le bouton est enfoncé, nous pouvons envoyer des données au Raspberry Pi via Série.

Ici, j’ai utilisé la série.fonction write() : elle envoie un octet ou une série d’octets. Ceci est différent de la série.print() qui rendra la sortie agréable à voir sur le moniteur série. Comme nous parlons à une autre machine et non à un humain, pas de problème avec cela.

Le numéro que nous envoyons ici est le 18. Ce n’est qu’un nombre aléatoire que nous associerons à l’état « le bouton a été poussé », donc lorsque le Raspberry Pi recevra un nombre, il vérifiera s’il est égal à 18. Vous pouvez imaginer envoyer différentes actions ou messages via la série, en utilisant des numéros différents.

Remarque: habituellement, vous pouvez également utiliser des interruptions Arduino pour savoir quand un bouton a été enfoncé. Si vous le faites, n’utilisez pas la bibliothèque série dans l’interruption. Si vous devez absolument utiliser des interruptions, définissez un indicateur dans l’interruption (une simple variable booléenne) et utilisez Serial dans votre fonction loop().

Et la deuxième action : gérer les 4 LEDs.

 if (Serial.available() > 0) { int ledNumber = Serial.read() - '0'; powerOffAllLEDs(); switch (ledNumber) { case 1: digitalWrite(LED_1_PIN, HIGH); break; case 2: digitalWrite(LED_2_PIN, HIGH); break; case 3: digitalWrite(LED_3_PIN, HIGH); break; case 4: digitalWrite(LED_4_PIN, HIGH); break; default: // wrong pin number, do nothing // all LEDs will be powered off break; } }

Nous vérifions d’abord si l’Arduino a reçu des données du Raspberry Pi via la communication série.

Si oui, nous lisons l’octet suivant avec Serial.lire(). Ici, vous pouvez remarquer une petite astuce, consistant à soustraire avec ‘0’, qui convertira le caractère en nombre qu’il représente – dans ce cas un entier.

Après cela, c’est assez simple. Nous éteignons toutes les LED, puis allumons uniquement la LED associée au nombre: 1, 2, 3 ou 4. Dans le cas où une mauvaise valeur est envoyée, aucune LED ne sera allumée.

Code Python Raspberry Pi 

#!/usr/bin/env python3import serialimport randomif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: number = ser.read() if number != b'': if int.from_bytes(number, byteorder='big') == 18: led_number = random.randint(1,4) print("Button has been pressed.") print("Sending number " + str(led_number) + " to Arduino.") ser.write(str(led_number).encode('utf-8'))

Nous ajoutons d’abord une ligne d’importation: la bibliothèque aléatoire Python.

Dans la boucle infinie (« while True »), nous lisons d’abord un octet de Serial. Le délai d’attente est fixé à 1 seconde. Si rien n’est reçu après une seconde, la fonction read() renverra b ».

Nous vérifions donc si ce que nous avons reçu est simplement vide (b ») ou s’il y avait vraiment quelque chose. Dans ce dernier cas, nous convertissons les données que nous avons reçues en un entier afin que nous puissions les utiliser dans le code. Pour cela, nous utilisons la fonction int.from_bytes(), qui décodera b’0x12′ (la représentation hexadécimale de 18 est 0x12) à 18.

Comme vous pouvez le voir, nous vérifions que le nombre est 18 pour continuer l’action. Si vous avez différentes commandes à gérer, l’utilisation d’un numéro différent pour chaque commande est une bonne pratique.

Nous choisissons un nombre aléatoire entre 1 et 4 pour déterminer lequel a conduit à la mise sous tension. Ensuite, nous l’envoyons avec la fonction pySerial write(). Pour envoyer un int via Serial, nous le convertissons d’abord en chaîne avec str(), puis l’encodons avec encode(‘utf-8’).

Test de l’application

Vous pouvez maintenant connecter l’Arduino au Raspberry Pi à l’aide du câble USB. Le Raspberry Pi alimentera alors à la fois l’Arduino et les 4 LED.

Si vous avez beaucoup de choses connectées à votre Arduino, vous voudrez peut-être ajouter une alimentation externe sur le connecteur d’alimentation Arduino. Par exemple, si vous souhaitez utiliser un moteur pas à pas, le Raspberry Pi n’aura jamais assez de courant pour lui-même + l’Arduino + le moteur. Dans ce cas, avec 4 LED, c’est OK.

Exécutez votre script Python et appuyez sur le bouton poussoir. Vous verrez un journal et l’une des LED de l’Arduino sera allumée.

$ chmod +x arduino_raspberry_pi_leds_button.py$ ./arduino_raspberry_pi_leds_button.py Button has been pressed.Sending number 3 to Arduino.Button has been pressed.Sending number 2 to Arduino.Button has been pressed.Sending number 4 to Arduino.Button has been pressed.Sending number 1 to Arduino.Button has been pressed.Sending number 3 to Arduino.Button has been pressed.Sending number 3 to Arduino.

Chaque fois que vous appuyez sur le bouton:

  • L’Arduino le détectera et en enverra 18 au Raspberry Pi.
  • Le Raspberry Pi recevra des données de série. Il vérifiera si le nombre est égal à 18. Si oui, un nombre aléatoire (entre 1 et 4) est choisi. Le Raspberry Pi enverra ce numéro à l’Arduino.
  • L’Arduino recevra ce numéro et allumera la LED associée.

Remarque : pour faire cette application plus rapidement et avec moins de code, vous pouvez également choisir d’utiliser le protocole Firmata, avec par exemple la bibliothèque pyFirmata sur Raspberry et la bibliothèque StandarfFirmata sur Arduino. Consultez ces tutoriels pour en savoir plus.

Conclusion

Dans ce tutoriel, vous avez appris à communiquer entre votre carte Raspberry Pi et Arduino via Série.

Maintenant, dans la vraie vie, cela vous sera-t-il utile? La réponse est oui, et assez souvent.

Le Raspberry Pi est idéal pour avoir beaucoup de puissance de calcul intégrée dans votre application. Vous pouvez exécuter des logiciels complets dans de nombreuses langues, des serveurs Web, des applications de robotique, etc. Le Raspberry Pi a certainement des GPIO que vous pouvez utiliser, mais ils ne sont pas aussi bons que ceux d’Arduino. En outre, vous avez plus de chances de graver votre Pi si vous faites quelque chose de mal avec le matériel.

L’Arduino est plus approprié pour manipuler directement les capteurs et actionneurs matériels: IMU, servomoteurs, moteurs pas à pas, tout ce qui nécessite plus de puissance, etc. – plus d’informations sur Quand utiliser Arduino vs Raspberry Pi.

Au total, les 2 cartes peuvent fonctionner parfaitement ensemble : le Raspberry Pi comme « cerveau  » de l’application, et l’Arduino comme « muscles », avec une communication série pour les faire se parler.