La GLAP-Box est un dispositif innovant qui permet d’afficher l’adresse IP wifi utilisée sur un écran LCD. Il s’agit d’une solution pratique et simple à utiliser pour les utilisateurs qui souhaitent connaître leur adresse IP wifi et la surveiller en temps réel. Grâce à cette technologie, les utilisateurs peuvent facilement vérifier leur adresse IP et s’assurer qu’elle est toujours la même. Dans cet article, nous allons examiner en détail les fonctionnalités et les avantages de la GLAP-Box et comment elle peut être utilisée pour afficher l’adresse IP wifi sur un écran LCD.
GLAP-Box : Afficher l’adresse IP wifi utilisée sur un écran LCD
(cliquer sur l’image pour agrandir)
1. Présentation
- Ce programme affiche sur un LCD l’adresse IP wifi utilisée par la GLAP-Box. On lance une commande ifconfig à partir de Processing et on analyse la sortie de la console système afin d’extraire l’adresse de l’interface wifi du système.
- Le résultat est envoyé vers la carte Arduino qui affiche la chaine de caractères reçue.
Ce programme utilise les fonctionnalités suivantes :
- Utilise la connexion série vers le PC
- Utilise un afficheur LCD alphanumérique en mode 4 bits
Ressources utiles associées à ce programme :
- La librairie Serial – pour les communications séries entre la carte Arduino et l’ordinateur ou d’autres composants
- La librairie LiquidCrystal pour afficheur LCD alphanumérique
2. Matériel Nécessaire
2.1 Un PC fixe + une carte Arduino + une GLAP-Box
- qui intègre l’espace de développement Arduino / Processing accessible par VNC depuis un PC fixe,
- … pour éditer, compiler le programme et programmer la carte Arduino.

2.2 Le matériel suivant pour réaliser le montage associé
- un afficheur LCD alpha-numérique (préparé pour une utilisation simplifiée en mode 4 bits avec la carte Arduino)

3. Instructions de montage
- La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
- Connexion du LCD sur les broches de la carte Arduino :
- Connecter broche RS du LCD sur la broche 8
- Connecter broche E du LCD sur la broche 9
- Connecter broche D4 du LCD sur la broche 10
- Connecter broche D5 du LCD sur la broche 11
- Connecter broche D6 du LCD sur la broche 12
- Connecter broche D7 du LCD sur la broche 13
4. Le schéma théorique du montage
Le schéma théorique du montage (cliquer pour agrandir)
5. Le circuit du montage
Le schéma du montage à réaliser (cliquer pour agrandir)
6. Le programme Arduino
6.1 Description
- La carte Arduino reçoit sur la port série la chaine de caractère correspondant à l’adresse IP reçue depuis l’interface Processing. La chaine reçue doit être au format IP=xxx.xxx.xxx.xxx= pour être prise en compte.
6.2 Le programme complet en langage Arduino
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 : 08/07/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 affiche sur la LCD la valeur de l’adresse IP
reçue sur le port série en provenance d’une interface Processing
*/
// — Fonctionnalités utilisées —
// Utilise la connexion série vers le PC
// Utilise un afficheur LCD alphanumérique en mode 4 bits
// ——– Circuit à réaliser ———
// La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
// Connexion du LCD sur les broches de la carte Arduino :
// Connecter broche RS du LCD sur la broche 8
// Connecter broche E du LCD sur la broche 9
// Connecter broche D4 du LCD sur la broche 10
// Connecter broche D5 du LCD sur la broche 11
// Connecter broche D6 du LCD sur la broche 12
// Connecter broche D7 du LCD sur la broche 13
// /////////////////////////////// 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 —
#include <LiquidCrystal.h> // Inclusion de la librairie pour afficheur LCD
// — Déclaration des constantes utiles —
// — Déclaration des constantes des broches E/S numériques —
const int RS=8; // Constante pour la broche 2
const int E=9; // Constante pour la broche 3
const int D4=10; // Constante pour la broche 4
const int D5=11; // Constante pour la broche 5
const int D6=12; // Constante pour la broche 6
const int D7=13; // Constante pour la broche 7
// — 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
String chaineTest=« »; // déclare un objet String pour analyse chaine réception
String chaineIP=« »; // déclare un objet String pour chaine adresse IP
int valeur1=0, valeur2=0; // variables int pour analyse chaine réception
int ligne, colonne; // variables de positionnement sur le LCD avec 1er caractère à ligne=0 et colonne=0
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
//———— Création d’un objet afficheur LCD alphanumérique —-
LiquidCrystal lcd(RS, E, D4, D5, D6, D7);// initialisation LCD en mode 4 bits
// ////////////////////////// 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 à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
// Initialisation de l’afficheur LCD
lcd.begin(20,4); // Initialise le LCD avec 20 colonnes x 4 lignes
delay(10); // pause rapide pour laisser temps initialisation
// Test de l’afficheur LCD
lcd.print(« LCD OK »); // affiche texte
delay (1000); //pause
lcd.clear(); // efface LCD
// ——- Broches en sorties numériques ——-
// ——- 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 ——-
delay (15000); // pause 15 secondes pour laisser le temps de la connexion wifi
} // 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 —
//—- 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 – activer Newline dans le Terminal
Serial.println (« Chaine recue= »+chaineReception); // affiche la chaine recue
//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
// —- analyse de la chaine recue sur le port Série —-
chaineReception=chaineReception.trim(); // enlève les espaces
// chaine reçue est au format IP=xxx.xxx.xxx.xxx=
if (chaineReception.substring(0,3)==« IP= ») { // si reçoit une chaine commençant par IP=
// nb substring : dernier caractere exclu
Serial.print(« IP= »); // affiche sur LCD
chaineIP=chaineReception.substring(3,chaineReception.length()–1); // extrait l’adresse IP
Serial.println(chaineIP); // affiche sur LCD
//———- si dernier caractere est bien un = on affiche la chaine
if (chaineReception.substring(chaineReception.length()–1,chaineReception.length())==« = ») {
lcd.clear();
lcd.home();
lcd.print(« IP= »);
lcd.print(chaineIP);
} // fin si dernier caractère est =
} // fin si IP=
chaineReception=« »; // RAZ chaine Reception
//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 ////////////////////
7. Le programme Processing
7.1 Description
- Ce programme lance l’exécution d’une commande système ifconfig qui donne la liste des interfaces réseau sur un système GNU/Linux.
- La sortie de la console est analysée afin d’extraire la valeur de l’adresse IP de l’interface wlan qui correspond à l’interface wifi
- La valeur est ensuite envoyée sur le port série au format IP=xxx.xxx.xxx.xxx=
7.2 Le programme complet en langage Processing
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 – Juillet 2011 – tous droits réservés
/////////////// Description du programme ////////////
// Ce programme fait exécuter la commande système ifconfig
// et extrait l’adresse ip de l’interface wlan (interface réseau wifi)
// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX
// inclusion des librairies utilisées
import processing.serial.*; // importe la librairie série processing
// déclaration objets
String[] command ;
String inputString;
String adresseIP;
// — port Série —
Serial myPort; // Création objet désignant le port série
int compt=0; // variable de comptage des passages
// déclaration variables globales
// XXXXXXXXXXXXXXXXXXXXXX Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX
void setup(){ // fonction d’initialisation exécutée 1 fois au démarrage
//————- 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
} // fin fonction Setup
// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX
void draw() { // fonction exécutée en boucle
getIP();
print(« Adresse IP wlan0: « );
println(inputString);
myPort.write(« IP= »+inputString+« =\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
void getIP() {
command = new String[1];
command[0] = « ifconfig »;
//command[1] = « »;
//command[2]= » »;
//command[3]= » »;
//command[4]= » »;
//command[5]= » »;
//command[6]= » »;
//command[7]= » »;
//— exécution de la ligne de commande
try {
Process p = exec(command); // exécute la commande
//— récupère la sortie de la commande dans la console de Processing
BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
String ligne = null;
while ((ligne = in.readLine()) != null) { // lit la sortie console ligne à ligne
System.out.println(ligne); // affiche la ligne courante issue de la console
//—– prise en compte de la ligne qui suit ligne avec chaine caractère wlan0 —
if (compt==1) { // si un premier passage a eu lieu
// mis avant détection « wlan » pour éviter prise en compte lors 1er passage
inputString=ligne; // on mémorise la ligne
compt=2; // incrémente compt pour éviter prise en compte des lignes non voulues
//—- traitement de la chaine de la deuxième ligne = extraction de l’IP
inputString=trim(inputString);
String[] subString = split(inputString, ‘:’); // coupe entre les :
inputString=subString[1]; // garde la sous-chaine :192….Bcast:
String[] subString2 = split(inputString, ‘ ‘); // coupe entre les :
inputString=subString2[0]; // garde la sous-chaine d’adresse IP
}
//———- recherche la première ligne qui concerne l’interface —
String[] testString = match(ligne, « wlan »); // recherche la chaine dans la ligne
if (testString != null) { // si le tableau n’est pas vide = si la chaine a été trouvée
inputString=ligne;
compt=1;
}
}
}
catch (IOException e) {
e.printStackTrace();
}
}
//———- fin programme ————
8. Utilisation concrète
- Ce programme peut être utile pour obtenir au démarrage du système l’adresse IP wifi attribuée à la GLAP-Box par le routeur wifi DHCP (attribution automatique d’adresse).
- Il suffira de transformer ce code en application Linux (Menu File > Export Application). On pourra mettre le répertoire obtenu sur le bureau de la GLAP-Box
- Ensuite, pour que le programme soit lancé au démarrage, on fera Système > Préférence > Application au démarrage > Ajouter > sélectionner le fichier .sh correspondant au programme.
- Redémarrer, la carte Arduino étant elle-même programmée et connectée à la GLAP-Box. L’adresse IP wifi doit s’afficher au lancement suivant.
Articles Liés
- Javascript : Graphique Dygraphs simple
Le Javascript est un langage de programmation très populaire et puissant qui permet aux développeurs…
- Javascript : Afficher 6 widgets graphiques fournis par une librairie graphique externe.
Le Javascript est un langage de programmation très populaire qui permet aux développeurs de créer…
- GLAP-Box : Procédures : Obtenir l'adresse IP Wifi de la GLAP-Box par accès éthernet.
La GLAP-Box est un dispositif de connectivité sans fil qui permet aux utilisateurs de se…