Arduino, Internet of Things (IoT), Tutoriels

Communication entre deux Arduino – Projet descriptif

Communication Entre Deux Arduino

1. Introduction

La communication entre deux Arduino est un projet fascinant qui démontre comment deux dispositifs séparés peuvent interagir via une connexion réseau TCP/IP. Dans ce projet, nous explorerons comment deux cartes Arduino UNO peuvent communiquer entre elles en utilisant un réseau Ethernet et le protocole TCP/IP.

2. Composants matériels

3. Schéma

Le schéma de câblage sera fourni pour vous guider dans les connexions entre les cartes Arduino et les modules Ethernet Shield.

Schéma De Connexion Entre Deux Arduino
Schéma de connexion entre deux Arduino

4. Installation des bibliothèques

Nous fournirons des instructions étape par étape pour télécharger et ajouter les bibliothèques nécessaires au projet. Ces bibliothèques incluent ezButton.h pour gérer l’entrée des boutons, SPI.h pour la communication avec le module Ethernet, et Ethernet.h pour la communication Ethernet.

5. Code pour Arduino #1

Nous présenterons en détail le code pour Arduino #1, qui agira en tant que client. Ce code comprendra l’initialisation des broches, la configuration du module Ethernet, la connexion au serveur (Arduino #2) et la gestion de l’envoi de commandes au serveur en fonction de l’état d’un bouton.

#include <ezButton.h>
#include <SPI.h>
#include <Ethernet.h>

const int BUTTON_PIN = 7;
const int serverPort = 4080;
ezButton button(BUTTON_PIN);  // create ezButton that attach to pin 7;

byte mac[] = {0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x03};
IPAddress serverAddress(192, 168, 0, 180);
EthernetClient TCPclient;

void setup() {
  Serial.begin(9600);
  button.setDebounceTime(50); // set debounce time to 50 milliseconds

  Serial.println("ARDUINO #1: TCP CLIENT + A BUTTON/SWITCH");

  // Initialize Ethernet Shield:
  if (Ethernet.begin(mac) == 0)
    Serial.println("Failed to configure Ethernet using DHCP");

  if (TCPclient.connect(serverAddress, serverPort))
    Serial.println("Connected to TCP server");
  else
    Serial.println("Failed to connect to TCP server");
}

void loop() {
  button.loop(); // MUST call the loop() function first

  if (!TCPclient.connected()) {
    Serial.println("Connection is disconnected");
    TCPclient.stop();

    if (TCPclient.connect(serverAddress, serverPort))
      Serial.println("Reconnected to TCP server");
    else
      Serial.println("Failed to reconnect to TCP server");
  }

  if (button.isPressed()) {
    TCPclient.write('1');
    TCPclient.flush();
    Serial.println("- The button is pressed,  sent command: 1");
  }

  if (button.isReleased()) {
    TCPclient.write('0');
    TCPclient.flush();
    Serial.println("- The button is released, sent command: 0");
  }
}

6. Code pour Arduino #2

Nous fournirons également le code pour Arduino #2, qui sera configuré comme serveur. Ce code comprendra la configuration du module Ethernet en tant que serveur, l’écoute des connexions entrantes, la réception des commandes du client (Arduino #1), et la commande de l’état de la LED en fonction des commandes reçues.

#include <SPI.h>
#include <Ethernet.h>

const int LED_PIN = 7;
const int serverPort = 4080;

byte mac[] = {0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02};
EthernetServer TCPserver(serverPort);

void setup() {
  Serial.begin(9600);
  pinMode(LED_PIN, OUTPUT);

  Serial.println("ARDUINO #2: TCP SERVER + AN LED");

  // Initialize Ethernet Shield:
  if (Ethernet.begin(mac) == 0)
    Serial.println("Failed to configure Ethernet using DHCP");

  // Print your local IP address:
  Serial.print("TCP Server IP address: ");
  Serial.println(Ethernet.localIP());
  Serial.println("-> Please update the serverAddress in Arduino #1 code");

  TCPserver.begin();
}

void loop() {
  EthernetClient client = TCPserver.available();

  if (client) {
    // Read the command from the TCP client:
    char command = client.read();
    Serial.print("- Received command: ");
    Serial.println(command);

    if (command == '1')
      digitalWrite(LED_PIN, HIGH); // Turn LED on
    else if (command == '0')
      digitalWrite(LED_PIN, LOW);  // Turn LED off

    Ethernet.maintain();
  }
}

7. Explication du fonctionnement

nous allons expliquer en détail le fonctionnement de la communication entre deux Arduino. Nous allons aborder les principaux aspects tels que l’initialisation, la connexion TCP/IP, la gestion des commandes, et les interactions entre le client (Arduino #1) et le serveur (Arduino #2).

Initialisation et Configuration

Avant de commencer la communication, chaque carte doit être correctement initialisé et configuré. Cela inclut l’activation des broches nécessaires, la configuration des adresses MAC pour les modules Ethernet, et l’attribution des adresses IP aux cartes Arduino.

Le code Arduino #1 est configuré en tant que client. Il utilise la bibliothèque ezButton pour gérer l’état d’un bouton connecté à une broche spécifique (dans cet exemple, la broche 7). Le code Arduino #2 est configuré en tant que serveur. Il utilise la bibliothèque Ethernet pour créer un serveur qui écoute les connexions entrantes sur un port spécifié (dans cet exemple, le port 4080).

Connexion TCP/IP

Une fois les initialisations effectuées, Arduino #1 (client) tente de se connecter à (serveur)#2 via une connexion TCP/IP. La connexion est établie en utilisant l’adresse IP du serveur (Arduino #2) et le numéro de port sur lequel le serveur écoute les connexions entrantes.

Lorsque la connexion est établie avec succès, le client (#1) peut envoyer des commandes au serveur. Dans cet exemple, les commandes sont des caractères ‘1’ et ‘0’. Le caractère ‘1’ indique que le bouton a été pressé, tandis que le caractère ‘0’ indique que le bouton a été relâché.

Interaction Client-Serveur

Le client (#1) surveille en permanence l’état du bouton à l’aide de la bibliothèque ezButton. Lorsque le bouton est pressé, le client envoie le caractère ‘1’ au serveur via la connexion TCP/IP. Lorsque le bouton est relâché, le client envoie le caractère ‘0’. Ces caractères sont envoyés à l’aide de la méthode TCPclient.write().

Le serveur (#2), de son côté, écoute en permanence les connexions entrantes à l’aide de la méthode TCPserver.available(). Lorsqu’une connexion est établie avec succès, le serveur lit les données reçues du client à l’aide de la méthode client.read().

En fonction de la commande reçue du client (#1), le serveur (#2) réagit en allumant ou en éteignant une LED connectée à une broche spécifiée (dans cet exemple, la broche 7). Lorsque le serveur reçoit le caractère ‘1’, il active la LED (en la mettant à HIGH), et lorsqu’il reçoit le caractère ‘0’, il désactive la LED (en la mettant à LOW).

Gestion des erreurs et de la connexion

Dans le code (#1), si la connexion avec le serveur (#2) est perdue pour quelque raison que ce soit, le client tente de se reconnecter. Il utilise la méthode TCPclient.connect() pour établir une nouvelle connexion avec le serveur.

Le serveur (#2) utilise la méthode Ethernet.maintain() pour gérer les tâches de maintenance du module Ethernet, telles que le renouvellement de la connexion DHCP si nécessaire.

8. Applications

Nous discuterons des diverses applications pratiques de cette communication. Cela peut inclure :

  • Systèmes de surveillance et de contrôle à distance
  • Systèmes intelligents de gestion de l’énergie
  • Applications de l’Internet des objets (IoT)
  • Robotique et automatisation
  • Réseaux des capteurs sans fil
  • Agriculture intelligente
  • Systèmes d’éclairage intelligents
  • Systèmes de sécurité et de surveillance.

9. Avantages de la Communication entre deux Arduino

La communication entre deux Arduino via une connexion TCP/IP présente de nombreux avantages. Tout d’abord, cette approche permet une communication bidirectionnelle fiable et rapide entre les dispositifs, ce qui ouvre un large éventail de possibilités pour les applications IoT, les systèmes de contrôle, et bien d’autres.

De plus, en utilisant le protocole TCP/IP, nous bénéficions d’une transmission de données sécurisée et robuste. Les protocoles réseau comme TCP/IP sont couramment utilisés dans le monde informatique pour leur fiabilité et leur capacité à gérer les erreurs de transmission.

Un autre avantage clé est l’extensibilité de cette approche. En utilisant une connexion réseau, nous pouvons étendre notre système pour inclure plus de dispositifs interconnectés sans compromettre la performance. Cela permet d’élargir les fonctionnalités du projet en ajoutant de nouveaux capteurs, actionneurs ou modules de communication.

10. Conclusion

La Communication entre deux Arduino est un projet passionnant qui permet d’explorer les possibilités de la communication réseau dans le monde de l’électronique et de l’automatisation. En combinant les capacités de communication des cartes Arduino avec les bibliothèques réseau, nous ouvrons la voie à une multitude d’applications pratiques et créatives.

En utilisant le guide fourni ici, vous serez en mesure de mettre en place un système de communication bidirectionnelle. Avec un peu de créativité et d’ingéniosité, vous pourrez étendre ce projet pour créer des systèmes plus complexes et répondant à des besoins spécifiques.

Nous espérons que ce projet vous a inspiré et vous a donné l’envie de continuer à explorer le vaste monde de l’électronique et de l’IoT. Bonne expérimentation !

Lien outilles

  1. Téléchargement de l’Arduino IDE : https://www.arduino.cc/en/software
  2. Pour plus d’articles : https://www.moussasoft.com/tutoriels-electroniques
  3. TwitterMoussa Lhoussaine (@Moussasoft_com) / Twitter

Arduino – Home