View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

GLAP-Box : Afficher l'adresse IP wifi utilisée sur un écran LCD

Par X. HINAULT - Page créée le : 9/7/2011.

(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 :

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é

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


// --- Programme 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

// Programme 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.