L’utilisation des technologies modernes pour contrôler des dispositifs à distance est devenue une pratique courante. Les cartes Arduino sont un excellent moyen de créer des systèmes de contrôle à distance, et leur utilisation pour allumer une LED à l’aide d’un bouton-poussoir et d’un réseau wifi est un excellent exemple de cette technologie. Dans cet article, nous allons examiner comment deux ordinateurs peuvent être connectés à un réseau wifi et comment une chaîne peut être envoyée pour allumer une LED sur une carte Arduino distante.
L’appui sur un BP allume une LED sur une carte Arduino distante par envoi d’une chaîne via 2 PC connectés à un réseau wifi.
Vue d’ensemble de la chaîne de communication utilisée.
- L’ensemble de la chaîne de transmission est la suivante :
Arduino départ <–usb–> Processing Client sur PC <–tcp–>(réseau wifi)<–tcp–> Processing sur PC Serveur <–usb–> Arduino arrivée
Cette chaîne va donc nécessiter 4 programmes distincts :
- le programme Arduino de la carte Arduino de départ qui envoie une chaîne sur le port Série vers le PC client lors Appui BP.
- le programme Processing du PC Client qui va recevoir la chaîne sur le port Série et la renvoyer vers le PC Serveur via le réseau Wifi
- le programme Processing du PC Serveur qui va recevoir la chaîne depuis le réseau wifi et l’envoyer vers la carte Arduino
- le programme Arduino de la carte Arduino d’arrivée qui reçoit la chaîne sur le Port Série depuis le PC Serveur.
- L’intérêt de cet ensemble de programmes et de cette chaîne de transmission est de faire la « preuve du concept » de transmission de données série via réseau wifi, en vue notamment du contrôle à distance d’un PC embarqué sur un robot à partir d’une carte Arduino de commande (Joystick) connectée à un PC, les 2 PC étant en réseau wifi via un routeur wifi.
A noter que pour développer ces 4 programmes, on pourra utilement créer un accès à distance au Bureau du PC Serveur depuis le PC Client à l’aide d’une communication VNC.
Etapes préalables à la mise en place du réseau wifi entre les 2 cartes Arduino.
La mise en place du réseau wifi entre les 2 PC nécessite :
- 2 PC (ou eeePC) avec la distribution Gnu/Linux Ubuntu installée. Pour plus d’info, voir ici : http://doc.ubuntu-fr.org/installation et/ou http://doc.ubuntu-fr.org/asus_eee_pc Même si je ne l’ai pas testée, il n’y a pas de raison pour que la procédure ne fonctionne pas sous les autres OS.
- la mise en place d’une connexion des 2 PC sur un routeur wifi configuré en DHCP (attribution automatique des adresses ip). Le routeur peut être une Livebox ou tout autre routeur wifi, avec ou sans accès internet (pas utilisé ici).
- de tester le réseau entre les 2 PC et de récupérer les adresses ip du PC serveur et du PC client. On s’est assuré notamment que le réseau fonctionne bien en réalisant un ping entre les 2 PC utilisés.
- d’ouvrir sur chaque PC le port utilisé pour communiquer entre les PC ainsi que sur le routeur.
Ici, nous utilisons le port 5905.
Une connaissance minimale en structure de réseau est nécessaire ici :
- savoir ce qu’est une adresse ip, un sous-masque réseau, un réseau
- savoir ce qu’est un port
- savoir ce qu’est un routeur, ce qu’est l’attribution des adresses ip en DHCP.
Rien d’inaccessible cependant !
le programme Arduino de la carte Arduino de départ qui envoie une chaîne sur le port Série vers le PC client lors Appui BP.
Le montage de la carte Arduino de départ
Le programme Arduino de la carte Arduino de départ
Pour tester le bon fonctionnement de ce programme, on pourra utiliser le Terminal Série.
A copier/coller directement dans l’éditeur Arduino
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr
// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 30/3/2011.
// ——- Licence du code de ce programme —–
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// //////////////////// PRESENTATION DU PROGRAMME ////////////////////
// ——– Que fait ce programme ? ———
/* L’appui sur un BP envoie une chaine sur le port Série.
Une LED témoigne de l’appui sur le BP. */
// — Fonctionnalités utilisées —
// Utilise la connexion série matérielle vers le PC
// Utilise / fonctionne avec une interface Processing coté PC
// ——– Circuit à réaliser ———
// La connexion série matérielle vers le PC utilise les broches 0 et 1 (via le câble USB)
// Broche 2 : Un BP connecté au 0V
// Broche 3 : Une LED et sa résistance en série connectée au 0V
// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles…
// — Déclaration des constantes —
// — Inclusion des librairies —
// — Déclaration des constantes utiles —
const int APPUI=LOW; // constante pour tester état BP
// — Déclaration des constantes des broches E/S numériques —
const int BP=2; // Constante pour la broche 2
const int LED=3; // Constante pour la broche 3
// — Déclaration des constantes des broches analogiques —
// — Déclaration des variables globales —
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
// ////////////////////////// 2. FONCTION SETUP = Code d’initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() { // debut de la fonction setup()
// — ici instructions à exécuter 1 seule fois au démarrage du programme —
// ——- Initialisation fonctionnalités utilisées ——-
Serial.begin(115200); // initialise connexion série matérielle à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
// ——- Broches en sorties numériques ——-
pinMode (LED,OUTPUT); // Broche LED configurée en sortie
// ——- Broches en entrées numériques ——-
pinMode (BP,INPUT); // Broche BP configurée en entrée
// ——- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ——-
digitalWrite (BP,HIGH); // Rappel au + activé sur la broche BP configurée en entrée
// ——- Initialisation des variables utilisées ——-
// ——- Codes d’initialisation utile ——-
} // fin de la fonction setup()
// ********************************************************************************
////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension
void loop(){ // debut de la fonction loop()
// — ici instructions à exécuter par le programme principal —
if (digitalRead(BP)==APPUI) { // si appui BP
digitalWrite(LED, HIGH); // allume LED
Serial.println(« Appui BP »); // envoie chaine sur le port série
delay(1000); // anti-rebond
digitalWrite(LED, LOW); // éteint LED
}
//while(1); // stop loop
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
le programme Processing du PC Client qui va recevoir la chaîne sur le port Série et la renvoyer vers le PC Serveur via le réseau Wifi
Description
Ce programme reçoit la chaine sur le port Série et l’envoie vers le Serveur.
Ressources utiles
- la librairie Processing Network : http://processing.org/reference/libraries/net/index.html
Le programme complet en langage Processing
Pour tester ce programme, il faut qu’un serveur soit actif. On pourra le tester en local avec un programme Serveur basique qui affiche la chaine reçue dans la console par exemple.
A copier/coller directement dans l’éditeur Processing
// généré avec le générateur de code Processing
// www.mon-club-elec.fr
// par X. HINAULT – Avril 2011 – tous droits réservés
/////////////// Description du programme ////////////
// Utilise le port Serie
// Utilise un Client réseau : ce programme nécessite un serveur réseau accessible
// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX
// inclusion des librairies utilisées
import processing.serial.*; // importe la librairie série processing
import processing.net.*; // importe la librairie pour connexion réseau Client/Serveur
// déclaration objets
// — port Série —
Serial myPort; // Création objet désignant le port série
// — objet Client Réseau —
Client myClient; // déclaration d’un objet client
String inStringServer; // pour réception chaine en provenance Serveur
// déclaration variables globales
// XXXXXXXXXXXXXXXXXXXXXX Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX
void setup(){ // fonction d’initialisation exécutée 1 fois au démarrage
// — initialisation des objets et fonctionnalités utilisées —
//————- initialisation port série —-
println(Serial.list()); // affiche dans la console la liste des ports séries
// Vérifier que le numéro du port série utilisé est le meme que celui utilisé avec Serial.list()[index]
myPort = new Serial(this, Serial.list()[0], 115200); // Initialise une nouvelle instance du port Série
//myPort = new Serial(this, « /dev/ttyUSB0 », 115200); // Initialise une nouvelle instance du port Série
myPort.bufferUntil(‘\n‘); // attendre arrivée d’un saut de ligne pour générer évènement série
//————- initialisation objet Client réseau —-
// Connexion du Client au serveur ayant l’adresse indiquée et sur le port indiqué
// 127.0.0.1 pour connexion en local sur la machine
myClient = new Client(this, « 127.0.0.1 », 12345); // Remplacer avec l’adresse IP du serveur et le numéro de port utilisé
//myClient = new Client(this, « 192.168.1.13 », 5905); // pour réseau local sur port 5905
// info : le port utilisé doit être ouvert sur le PC client et le PC serveur ainsi que sur le routeur du réseau
} // fin fonction Setup
// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX
void draw() { // fonction exécutée en boucle
//————- Code pour port série —-
// myPort.write(‘H’); // envoie le caractère sur le port Série
// myPort.write(« chaine\n »); // envoie la chaine suivi saut ligne sur le port Série
// while(true); // stoppe boucle draw
} // fin de la fonction draw()
// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX
//————- Fonction de gestion des évènements série —-
void serialEvent (Serial myPort) { // fonction appelée lors de la survenue d’un évènement série
// ******** Gestion de la valeur reçue sur le port série : **********
String inString = myPort.readStringUntil(‘\n‘); // chaine stockant la chaîne reçue sur le port Série
// saut de ligne en marque de fin
if (inString != null) { // si la chaine recue n’est pas vide
// print (inString); // affichage brut de la chaine recue
inString = trim(inString); // enlève espace blancs de la chaine recue
int inByte_brut=int(inString); // conversion valeur reçue en valeur numérique entiere
float inByte = float(inString); // conversion valeur reçue en valeur numérique décimale
//————- Code pour Client Réseau —-
myClient.write(inString+« \n« ); //— envoie une chaine vers le Serveur suivie d’un saut de ligne
//delay(1000); // entre deux envois
} // fin condition chaine recue pas vide
} // fin de la fonction de gestion des évènements Série
le programme Processing du PC Serveur qui va recevoir la chaîne depuis le réseau wifi et l’envoyer vers la carte Arduino
// généré avec le générateur de code Processing
// www.mon-club-elec.fr
// par X. HINAULT – Avril 2011 – tous droits réservés
/////////////// Description du programme ////////////
// Utilise le port Serie
// Utilise un Serveur réseau
// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX
// inclusion des librairies utilisées
import processing.serial.*; // importe la librairie série processing
import processing.net.*; // importe la librairie pour connexion réseau Client/Serveur
// déclaration objets
// — port Série —
Serial myPort; // Création objet désignant le port série
// — objet Client Réseau —
Client myClient; // déclaration d’un objet client
// — objet Serveur Réseau —
Server myServer; // déclaration d’un objet Serveur
String inStringClient; // pour réception chaine en provenance Client
// déclaration variables globales
// XXXXXXXXXXXXXXXXXXXXXX Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX
void setup(){ // fonction d’initialisation exécutée 1 fois au démarrage
// — initialisation des objets et fonctionnalités utilisées —
//————- initialisation port série —-
println(Serial.list()); // affiche dans la console la liste des ports séries
// Vérifier que le numéro du port série utilisé est le meme que celui utilisé avec Serial.list()[index]
myPort = new Serial(this, Serial.list()[0], 115200); // Initialise une nouvelle instance du port Série
//myPort = new Serial(this, « /dev/ttyUSB0 », 115200); // Initialise une nouvelle instance du port Série
myPort.bufferUntil(‘\n‘); // attendre arrivée d’un saut de ligne pour générer évènement série
//————- initialisation objet Serveur réseau —-
//myServer = new Server(this, 12345); // Ouvre un simple Serveur – Remplacer avec le numéro de port utilisé
myServer = new Server(this, 5905); // Ouvre un simple Serveur sur port 5905
// info : le port utilisé doit être ouvert sur le PC client et le PC serveur ainsi que sur le routeur du réseau
// info : l’adresse du serveur devra être utilisé par le client
} // fin fonction Setup
// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX
void draw() { // fonction exécutée en boucle
//————- Code pour port série —-
// myPort.write(‘H’); // envoie le caractère sur le port Série
// myPort.write(« chaine\n »); // envoie la chaine suivi saut ligne sur le port Série
//————- Code pour Serveur Réseau —-
myClient = myServer.available(); // l’objet client est un client connecté au serveur si il existe
if (myClient != null) { // si myClient existe
inStringClient = myClient.readString(); // lit la chaine envoyée par le Client
println (« Chaine reçue= »+inStringClient); // affiche la chaine reçue
//inStringClient = inStringClient.substring(0, inStringClient.indexOf(« \n »)); // Garde uniquement ce qui est avant le saut de ligne
//—- renvoi de la chaine reçue sur le port Série
myPort.write(inStringClient+« \n« ); // envoie la chaine suivi saut ligne sur le port Série
} // fin si client existe
// while(true); // stoppe boucle draw
} // fin de la fonction draw()
// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX
//————- Fonction de gestion des évènements série —-
void serialEvent (Serial myPort) { // fonction appelée lors de la survenue d’un évènement série
// ******** Gestion de la valeur reçue sur le port série : **********
String inString = myPort.readString(); // chaine stockant la chaîne reçue sur le port Série
// saut de ligne en marque de fin
if (inString != null) { // si la chaine recue n’est pas vide
// print (inString); // affichage brut de la chaine recue
inString = trim(inString); // enlève espace blancs de la chaine recue
println(« Arduino a reçu: » + inString);
} // fin condition chaine recue pas vide
} // fin de la fonction de gestion des évènements Série
le programme Arduino de la carte Arduino d’arrivée qui reçoit la chaîne sur le Port Série depuis le PC Serveur.
Le montage de la carte Arduino d’arrivée
Le programme Arduino de la carte Arduino d’arrivée
A copier/coller directement dans l’éditeur Arduino
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr
// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 30/3/2011.
// ——- Licence du code de ce programme —–
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// //////////////////// PRESENTATION DU PROGRAMME ////////////////////
// ——– Que fait ce programme ? ———
/* Ce programme allume une LED à la réception d’une chaine sur le port Série.
La chaîne reçue est renvoyée sur le port Série, attestant sa bonne réception. */
// — Fonctionnalités utilisées —
// Utilise la connexion série matérielle vers le PC
// ——– Circuit à réaliser ———
// La connexion série matérielle vers le PC utilise les broches 0 et 1 (via le câble USB)
// Broche 2 : Une LED et sa résistance en série connectée au 0V
// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles…
// — Déclaration des constantes —
// — Inclusion des librairies —
// — Déclaration des constantes utiles —
// — Déclaration des constantes des broches E/S numériques —
const int LED=2; // Constante pour la broche 2
// — Déclaration des constantes des broches analogiques —
// — Déclaration des variables globales —
int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
long nombreReception=0; // variable de stockage du nombre reçu sur le port Série
long nombreReception0=0; // variable de stockage du dernier nombre reçu sur le port Série
String chaineReception=« »; // déclare un objet String vide pour reception chaine
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
// ////////////////////////// 2. FONCTION SETUP = Code d’initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() { // debut de la fonction setup()
// — ici instructions à exécuter 1 seule fois au démarrage du programme —
// ——- Initialisation fonctionnalités utilisées ——-
Serial.begin(115200); // initialise connexion série matérielle à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
// ——- Broches en sorties numériques ——-
pinMode (LED,OUTPUT); // Broche LED configurée en sortie
// ——- Broches en entrées numériques ——-
// ——- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ——-
// ——- Initialisation des variables utilisées ——-
// ——- Codes d’initialisation utile ——-
} // fin de la fonction setup()
// ********************************************************************************
////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension
void loop(){ // debut de la fonction loop()
// — ici instructions à exécuter par le programme principal —
//—- code type réception chaine sur le port série —
while (Serial.available()>0) { // tant qu’un octet en réception
octetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable
if (octetReception==10) { // si Octet reçu est le saut de ligne
digitalWrite(LED,HIGH); // allume la LED
delay(500); // pause
Serial.println (chaineReception); // affiche la chaine recue
digitalWrite(LED,LOW); // éteint LED
chaineReception=« »; //RAZ le String de réception
break; // sort de la boucle while
}
else { // si le caractère reçu n’est pas un saut de ligne
chaineReception=chaineReception+char(octetReception); // ajoute le caratère au String
}
} // fin tant que octet réception
//—– une fois que le saut de ligne est reçu, on sort du While et on se positionne ici
//while(1); // stop loop
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////
// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////
// ////////////////////////// Fin du programme ////////////////////
