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 |

Test simple de réception d'une chaine de caractère par le module wifi RedFly en serveur réseau depuis PC client réseau via le réseau wifi.

Par X. HINAULT - Page créée le : 25/4/2011.

1.  Présentation

  • Ce programme teste la réception simple, sans fil via le réseau wifi, d'une chaine de caractères par le shield Arduino wifi RedFly de chez Watterott configuré en serveur.
  • Le client est ici une interface Processing côté PC qui dispose d'un champ texte et d'un bouton graphique pour déclencher l'envoi d'une chaine vers le module wifi RedFly configuré en serveur.
  • Bien que tout se passe en local (le module wifi RedFly en place sur une carte Arduino est connecté au port série du PC, PC qui est lui-même connecté au réseau wifi..), l'intérêt ici est de poser les bases d'une communication distante entre le module wifi RedFly et le PC, pour l'envoi de chaines de caractères, et donc de données utiles, sans fil. Cette façon de développer l'application wifi embarquée en local simplifie grandement la mise au point.
  • On réalise ici une connexion en mode "attribution automatique" des adresses ip par le routeur (mode DHCP). Il est tout à fait possible de réaliser une configuration manuelle également, sous réserve d'adapter le programme à votre cas particulier.

Ce programme utilise les fonctionnalités suivantes :

  • Utilise la connexion série vers le PC
  • Utilise le stockage des variables en mémoire Flash Programme

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 Flash - pour mettre simplement les chaînes de caractères et constantes de vos programmes dans la mémoire Flash programme de votre carte Arduino. Attention : nécessite une petite modification du fichier print.h, à faire une fois pour toute.
  • La librairie RedFly - pour le contrôle du shield Arduino wifi RedFly de chez Watterott.

2.  Matériel Nécessaire

2.1  L'espace de développement Arduino

  • ... 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)
  • Le shield Arduino wifi RedFly s'enfiche broche à broche sur la carte Arduino

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.  Note technique concernant la communication série avec le module wifi RedFly

  • Le module wifi RedFly communique avec la carte Arduino en utilisant le port série matériel, c'est à dire le même que celui qui est utilisé pour programmer et communiquer avec la carte Arduino, à savoir les broches 0 et 1 de la carte Arduino (Uno ou Duemilanove).
  • A première vue, ceci empêche la communication série entre le PC et la carte Arduino pendant l'exécution du programme. En fait, cette communication est possible sous réserve de quelques contraintes à savoir :
    • le débit utilisé doit être le même que celui utilisé par la communication série entre le module wifi RedFly et la carte Arduino, à savoir 9600 bauds.
    • avant toute utilisation de la communication série pendant l'exécution du programme entre le PC et la carte Arduino, il faudra désactiver puis réactiver la communication série avec le module, ce qui se fait à l'aide de 2 fonctions dédiées de la librairie pour le module RedFly, les fonctions enable() et disable().
  • Au sein des programmes Arduino, il faudra cependant veiller à ne pas utiliser la communication série entre la carte Arduino et le PC lorsque le module wifi et la carte Arduino communiquent entre-eux, sous peine d'obtenir une perte de données issues du module wifi.
  • A noter que l'utilisation du Terminal série configuré en 9600 bauds permettra de visualiser les messages de communication entre le module wifi et la carte Arduino.

7.  Mise en place du réseau wifi : étape préparatoire

  • Ce programme nécessite un réseau wifi local opérationnel entre le PC utilisé, un routeur Wifi en mode d'attribution automatique des adresses (DHCP) et la carte wifi RedFly.

Pour ce programme, vous avez besoin de connaître les éléments suivants :

  • le nom du réseau ou SSID ( se connecter depuis le PC à l'interface du routeur - 192.168.1.1 dans mon cas)
  • le numéro du réseau (chiffres en xxx.xxx.xxx. de l'adresse ip - en rouge sur le schéma)
  • connaître d'adresse ip du PC (sous Ubuntu, ifconfig dans un terminal)

Vous devez vérifier notamment :

  • que le sous-masque du réseau est bien 225.255.255.0 au niveau du routeur. A modifier le cas échéant.
  • Concrètement :
    • 1. vous branchez votre routeur wifi, qui peut être votre Box ou un routeur wifi acheté exprès (configuré en mode DHCP (=attribution automatique d'adresse) par défaut normalement). La connexion à internet n'est pas nécessaire ici.
    • 2. vous connectez votre PC au réseau wifi comme vous le feriez d'habitude (pas de clé wep nécessaire normalement - si on vous en demande une, elle doit être fournie par le fabricant ou FAI). Connectez-vous en mode "infra-structure", le mode "ad-hoc" correspondant à une connexion directe entre 2 éléments du réseau)
    • 3. Une fois la connexion faite, récupérer et noter l'adresse ip attribuée à votre PC (sous Ubuntu, faire $ ifconfig dans une console)
    • 3. vous ouvrez un navigateur et vous connectez à l'adresse de votre routeur (de la forme http://192.168.1.1 - le numéro est fourni par la documentation fabricant / FAI) : vous arrivez dans l'interface du routeur. Noter les éléments voulus : le SSID, le numéro réseau, le masque, ... et modifier le sous-masque réseau au besoin.
    • 4. Mettez le module RedFly sur la carte Arduino et connecter la carte au port Série : vous devez avoir une LED verte et une rouge qui s'allument sur le shield RedFly.
    • 5. Vous pouvez passer à la suite...

Voir également :

8.  Explication du programme

Les étapes types de la connexion du module RedFly à un réseau wifi sont les suivantes :

  • 1. initialisation du module avec la fonction init()
  • 2. Détection du/des réseaux avec la fonction scan()
  • 3. connexion au réseau wifi à l'aide de son identifiant (ssid), en mode ouvert ou crypté (WEP, WAP..), à l'aide de la fonction join()
  • 4. configuration des paramètres du réseau (ip, passerelle, ..) avec la fonction begin()
  • 5. ouverture de la ligne réseau, en fixant le protocole (UDP ou TCP) et le port, avec la fonction socketListen
  • 6. lecture/écriture des données sur la ligne réseau avec les fonctions socketRead() et socketSend()
  • Pour plus d'informations sur les fonctions, voir : librairie RedFly
  • voir les commentaires détaillés du programme.

9.  Mise en oeuvre du programme

9.1  Préparation du montage et programmation de la carte Arduino :

  • Commencer par réaliser le montage indiqué sur plaque d'expérimentation
  • Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle

9.2  Préparation du Terminal côté PC dans le logiciel Arduino

  • Côté PC, il faut ouvrir la fenêtre terminal de l'IDE Arduino : pour ce faire, un simple clic sur le bouton « Sérial Monitor ».
  • La fenêtre « Terminal » s'ouvre alors :
  • Il faut alors régler le débit de communication sur la même valeur que celle utilisée par le programme avec lequel nous allons programmer la carte Arduino :
  • Utiliser ici une débit de 9600 bauds, seul débit possible car c'est le débit série utilisé par la communication entre le module wifiRedFly et la carte Arduino

9.3  Fonctionnement

  • Une fois la carte programmée, ouvrir le Terminal série en 9600 bauds et faire un reset sur la carte : vous devez obtenir les messages indiquant que la connexion au réseau wifi s'est bien déroulée. (Tous les messages commençant par AT+RSI correspondent aux messages de communication entre le module wifi Redfly et la carte Arduino)
  • Ensuite, lancer l'interface Processing sur le PC (voir programme ci-dessous) en adaptant au préalable les paramètres réseau à votre situation. Vous devez obtenir une fenêtre avec un champ texte et un bouton graphique : saisissez du texte et clic sur le bouton d'envoi.
  • Vous devez voir apparaître la chaine envoyée dans le Terminal série, prouvant bien que la chaîne a été transmise par le réseau wifi et a bien été reçue par le module wifi RedFly.
  • Des messages dans la console de Processing témoignent également du bon déroulement de la connexion du client au serveur réseau et de l'envoi de la chaine du client Processing vers le serveur réseau :

10.  Le programme complet en langage Arduino

A copier/coller directement dans l'éditeur Arduino

  • Adapter les paramètres réseaux à votre cas particulier, notamment le nom du réseau.

// --- 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 : 25/4/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 réalise un simple serveur Http wifi (port 80) à l'aide du shield Arduino wifi RedFly de chez Watterott.

Ce serveur se contente d'afficher dans le Terminal série les chaines reçues par le réseau wifi
*/


// --- Fonctionnalités utilisées ---

// Utilise la connexion série matérielle vers le PC
// Utilise le stockage des variables en mémoire Flash Programme

// -------- Circuit à réaliser ---------

// La connexion série matérielle vers le PC utilise les broches 0 et 1 (via le câble USB)
// Module wifi Redfly de chez Watterott connecté broche à broche sur la carte Arduino
// utilise les broches 0 et 1 (communication série matérielle) + broches 3 et 4

// /////////////////////////////// 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 <Flash.h> // Inclusion librairie pour stockage en mémoire Flash Programme
// Avant utilisation, il faut installer manuellement cette librairie
// dans le dossier <Libraries> du dossier Arduino
// infos : www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.LibrairieFlashProgramme

#include <RedFly.h> // inclusion de la librairie pour shield Arduino wifi RedFly (watterott)
// Avant utilisation, il faut installer manuellement cette librairie
// dans le dossier <Libraries> du dossier Arduino
// infos : www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.LibrairieRedFly

// --- Déclaration des constantes utiles ---

// --- Déclaration des constantes des broches E/S numériques ---


// --- Déclaration des constantes des broches analogiques ---


// --- Déclaration des variables globales ---

//------ variables pour le réseau wifi avec le module RedFly ----
byte ip[]      = { 192,168,  2, 10 }; //tableau contenant adresse ip du shield wifi RedFly (serveur) - 4 octets
byte netmask[] = { 255,255,255,  0 }; // tableau contenant le masque de sous-réseau - 4 octets

byte mac[]= {0,0,0,0,0,0}; //tableau contenant l'adresse mac du module wifi - 6 octets

//unsigned int port=80; // port utilisé pour la connexion
unsigned int port=5905; // port utilisé pour la connexion

byte ligneReseau=0xFF; // identifiant de ligne réseau
int ligneReseau_len=0; // réception len
char ligneReseau_buf[100]; // buffer de réception

//----- debug - tableau de la variable rd où est stocké la valeur renvoyée par la fonction socketRead()
//String mem_rd=""; // Pour mémoriser les valeurs de la variable rd
char mem_rd[100]; // pour mémoriser les valeurs de la variable rd
int compt_rd=0; // pour comptage nombre valeur de la variable rd

char ssid[32]; // tableau pour stocker ssid (nom du réseau)
byte mode; // variable pour stocker mode du réseau (0=Open, 1=WPA, 2=WPA2, 3=WEP)
byte rssi; // variable pour stocker rssi (la force du signal réseau)


// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---

// l'objet RedFly est automatiquement créé lors de l'inclusion de la librairie
// toutes les fonctions de la librairie RedFly s'appliquent à cet objet sous la forme RedFly.fonction()

// ////////////////////////// 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(9600); // initialise connexion série matérielle à 9600 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
// Module RedFly : la communication série avec le module se fait à 9600 Bauds

delay(100); // delai avant communication avec module wifi

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

// ------- Codes d'initialisation utile -------  

//------------ initialisation du module wifi RedFly ----

  byte ret; // variable pour stockage valeur renvoyées par fonctions utilisées

  //initialisation du module wifi intégré sur le shield RedFly
  ret = RedFly.init(HIGH_POWER); // initialise le module wifi avec niveau HAUT série = 5V - valeur renvoyée stockée dans ret
  //valeurs possibles : LOW_POWER MED_POWER HIGH_POWER

  if(ret!=0) { // si la fonction init() n'a pas renvoyé 0  

    debugoutln("Echec initialisation module wifi"); // affiche message

  } // si échec initialisation module wifi

  else { // si la fonction init a renvoyé 0 càd si initialisation réussie

    debugoutln("Initialisation module wifi OK"); // affiche message

    //récupération de l'adresse MAC du module wifi
    RedFly.getmac(mac); // récupère l'adresse mac et la met dans le tableau reçu par la fonction


    //------------ affiche adresse MAC au format xx:xx:xx:xx:xx:xx
    RedFly.disable(); // désactive communication série avec module wifi avant utilisation Serial.print

    Serial.print("Adresse MAC du module : "); // affiche message

    for (int i=0; i<6; i++) { // défile les 6 octets

      if (mac[i]<10) Serial.print(0,HEX),Serial.print(mac[i],HEX), Serial.print(":"); // affiche message
      else Serial.print(mac[i],HEX), Serial.print(":");

    } // fin for

    Serial.println(); // saut de ligne
    Serial.println(); // saut de ligne

    RedFly.enable(); // ré-active communication série avec module wifi après utilisation Serial.print

    //------------- détection réseau sans fil disponible ----------

    RedFly.disable(),Serial.println("---- recherche reseau wifi disponible ----"), RedFly.enable(); // affiche message

    //on commence par rechercher un réseau sans fil disponible -- à faire avant join()
    //RedFly.scan(); // recherche réseau sans récupérer infos

    //scan(char ssid[], uint8_t *mode, uint8_t *rssi)
    ret=RedFly.scan( ssid, &mode, &rssi); // recherche réseau et récupère infos dans variables reçues par la fonction

    //-- affichage des valeurs récupérées --
    RedFly.disable(); // désactivation série module wifi

//    Serial.print("Valeur renvoyee = "), Serial.println(int(ret)); // affiche valeur de ret
    Serial.print("Nom reseau detecte : "), Serial.println(ssid);
    Serial.print("Mode reseau (0=Open, 1=WPA, 2=WPA2, 3=WEP) = "), Serial.println(int(mode));
    Serial.print("Force du signal = "), Serial.print(int(rssi)), Serial.println("%");
    Serial.println(); // saut de ligne

    RedFly.enable(); // ré-activation série module wifi

    //---- recherche plusieurs réseaux disponibles ---
    // --- nextscan() semble devoir etre précéde de scan()
/*
    RedFly.disable(), Serial.println("---- recherche des 5ers reseaux wifi disponibles ----"), Serial.println(), RedFly.enable(); // affiche message

    for (int i=0; i<5; i++) { // détecte les 5 premiers réseaux trouvés

    ret=RedFly.nextscan( ssid, &mode, &rssi); // recherche réseau et récupère infos dans variables reçues par la fonction

    //-- affichage des valeurs récupérées --
    RedFly.disable(); // désactivation série module wifi

//  Serial.print("Valeur renvoyee = "), Serial.println(int(ret)); // affiche valeur de ret
    Serial.print("Nom reseau detecte : "), Serial.println(ssid);
    Serial.print("Mode reseau (0=Open, 1=WPA, 2=WPA2, 3=WEP) = "), Serial.println(int(mode));
    Serial.print("Force du signal = "), Serial.print(int(rssi)), Serial.println("%");
    Serial.println(); // saut de ligne

    RedFly.enable(); // ré-activation série module wifi

    } // fin for i détection n premiers réseaux trouvés
*/
   

    //------------- Connexion au réseau détecté ---------------
    //ret = RedFly.join("belkin54g", "ADB48F70E9B9B2733C2FA8D90E",INFRASTRUCTURE); //"wlan" (SSID=nom), "12345678" (clé wep ou wap), INFRASTRUCTURE or IBSS_JOINER
    //ret = RedFly.join("Livebox-f0c2", "FAD994A61922743DA3DC1933F5",INFRASTRUCTURE); //"wlan" (SSID=nom), "12345678" (clé wep ou wap), INFRASTRUCTURE or IBSS_JOINER
    //ret = RedFly.join("NETGEAR", "",INFRASTRUCTURE); //"wlan" (SSID=nom), "12345678" (clé wep ou wap), INFRASTRUCTURE or IBSS_JOINER
    ret = RedFly.join("NETGEAR"); //"wlan" (SSID=nom) - connexino sur réseau non sécurisé par clé wep = le plus simple

    if(ret!=0) { // si valeur renvoyée par join n'est pas nulle = erreur de connexion

      debugoutln("Erreur de connexion au reseau wifi !");

    } // fin if

    else { // si valeur renvoyée par join nulle = connexion au réseau wifi réussie

       debugoutln("Connexion au reseau wifi : OK !");

      //configuration de l'adresse IP du module wifi
      ret = RedFly.begin(); //attribution automatique - avec un routeur en mode DHCP - le plus simple

      //ret = RedFly.begin(ip);
      //ret = RedFly.begin(ip, gateway);
      //ret = RedFly.begin(ip, gateway, netmask);
      //ret = RedFly.begin(ip, 0, netmask);

        if(ret!=0) { // si la valeur renvoyée par la fonction begin n'est pas nulle = en cas d'erreur de configuration

          debugoutln("Erreur de configuration initiale parametres reseau");
          RedFly.disconnect();
          debugoutln("Deconnexion du reseau wifi");

        }// fin if

        else {

          debugoutln("Configuration initiale parametres reseau : OK !");

          //------------- ouverture de la ligne réseau en écoute ------------

          ligneReseau = RedFly.socketListen(PROTO_TCP, port); //lance écoute sur le port 80 en utilisant le protocole TCP = serveur sur port défini
          // socketListen renvoie 0xFF si erreur... sinon, renvoie le numéro de la ligne en écoute

          if(ligneReseau == 0xFF) { // la fonction socketListen renvoie 0xFF si erreur... sinon, renvoie le numéro de la ligne en écoute

            debugoutln("Erreur de connexion ligne reseau");

              RedFly.disconnect();
              debugoutln("Deconnexion du reseau wifi");

            }// fin if

          else { // si pas d'erreur

            //debugoutln("Ecoute ligne reseau TCP sur port 80 : OK !");

            RedFly.disable();
            Serial.print("Ecoute ligne reseau TCP sur port ");
            Serial.print(port);
            Serial.println(" : OK !");
            RedFly.enable();

          }// fin else

        } // fin else

    } // fin else


  } // fin si Initialisation module OK


// -------- fin initialisation module wifi Redfly -------------


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

//--------------- gestion des connexions clients entrantes -----------------

  //uint8_t sock, buf[32];
  byte sock, buf[32]; // sock = numéro de ligne en écoute - buf = buffer réception

  //uint16_t rd, len;
  int unsigned rd, len; // rd = mémorise retour de socketRead()=taille des données lues ? - len : taille totale des données disponibles


  if(ligneReseau == 0xFF) // si il n'y a pas de ligne réseau ouverte - cf socketListen()

  {

    return; // sort de la fonction

  }



  sock = 0xff; //pour renvoi des données de toutes les lignes réseau
  // paramètre passé à la fonction socketRead()

  rd = RedFly.socketRead(&sock, &len, 0, 0, buf, sizeof(buf));
  // la fonction socketRead renvoie le nombre de données lues = mises dans le buffer destination


  if(sock == ligneReseau) // si la ligne lue est la ligne Réseau voulue (port défini)

  {

/*    //--------- éviter les messages pendant la lecture des données en réception car çà perturbe la communication entre redfly et Arduino
     //-------- affiche message -----
  if (rd!=0) { // si des données ont été lues --
    RedFly.disable();
    Serial.print("rd =");
    Serial.println(rd);
    RedFly.enable();
  }

*/


    if((rd != 0) && (rd != 0xffff)) // si la fonction socketRead() n'a pas renvoyé 0 (= des données ont été lues)
    // et n'a pas renvoyé 0xFFFF (= connexion interrompue)
    // il semble que la fonction socketRead() renvoie 1 à chaque passage --

    {

      //---------- pour éviter débordement buffer réception ligne réseau -----------

      if((ligneReseau_len+rd) > sizeof(ligneReseau_buf)) // si la longueur données déjà présente dans buffer + taille données lues > taille buffer

      {

        rd = sizeof(ligneReseau_buf)-ligneReseau_len; // la taille données lues est réduite à la place restante dans buffer ligne Reseau

      }

      //--------- récupération données reçues par réseau dans buffer réception ligne réseau

      memcpy(&ligneReseau_buf[ligneReseau_len], buf, rd); // copie dans http buffer le contenu de buf longueur rd (?)

      ligneReseau_len += rd; // incrémente longueur données présentes dans http buffer de la quantité données rd


      //--- mémorisation valeur rd pour affichage --
      //mem_rd=mem_rd+rd; // ajoute la valeur de rd au String
      //mem_rd[compt_rd]=rd+48; // mémorise valeur ascii de rd
      if (compt_rd<(sizeof(mem_rd)-1)) mem_rd[compt_rd]=rd+48; // mémorise valeur ascii de rd tant que compt_rd < taille tableau mem_rd
      compt_rd ++; // incrémente compt_rd

    } // fin si (rd != 0) && (rd != 0xffff)



    if((rd == 0xffff)  || (len == 0)) // si la connexion est fermée ou si toutes les données sont lues

    {

      //ferme la ligne réseau si connexion fermée - sinon laisse ouvert pour nouvelle réception
      if (rd == 0xffff) RedFly.socketClose(sock);


      //affiche le contenu du http buffer
      ligneReseau_buf[sizeof(ligneReseau_buf)-1] = 0; // met 0 dans la dernière case de http buffer (une chaine de caractère se termine par 0)

      debugoutln(ligneReseau_buf); // affiche le contenu du http buffer - possible une fois communication entre Redfly et Arduino finie

      mem_rd[sizeof(mem_rd)-1]=0; // met 0 dans dernière case du tableau (une chaine de caractère se termine par 0)

      debugout("Valeurs rd : "); // affiche message      
      debugoutln (mem_rd); // affiche liste valeur des rd

      RedFly.disable();
      Serial.print("comptage rd : ");
      Serial.println(compt_rd);
      RedFly.enable();

      //-------- réinitialise réception nouvelle chaine -----------
      compt_rd=0; // RAZ compt_rd

      for (int i=0; i<ligneReseau_len; i++) ligneReseau_buf[i]=' '; // RAZ des caractères utilisés du buffer ligneReseau

      ligneReseau_len=0; // RAZ ligneReseau_len

    } // fin si len==0

  } // fin si sock == ligneReseau



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

//--------- fonctions pour affichage Terminal série avec shield RedFly ---
//---- chacune de ces fonctions désactive/active la communication série et utilise fonction Serial.print ou Serial.println
void debugout(char *s)  { RedFly.disable(); Serial.print(s);   RedFly.enable(); }
void debugoutln(char *s){ RedFly.disable(); Serial.println(s); RedFly.enable(); }


// ////////////////////////// Fin du programme ////////////////////

 

11.  Le programme complet en langage Processing

11.1  Explication

  • Ce programme réalise un client réseau sur le PC.
  • Un champ texte permet la saisie d'une chaine de caractère qui est envoyée sur le réseau vers le serveur indiqué dans le programme.

11.2  Ressources utiles

  • Librairie GUI controlP5
  • Librairie Network

11.3  Le programme complet en langage Processing

A copier/coller directement dans l'éditeur Processing

  • Adapter les paramètres réseaux à votre cas particulier, notamment l'adresse ip du module wifi serveur et le port utilisé qui doit être le même que le programme Arduino.
  • Noter que le port utilisé doit également être ouvert sur le routeur utilisé. C'est le cas par défaut pour le port 80 (http).

// Programme 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 un/des objets String (chaîne de caractère)
// Utilise le port Serie
// Utilise un Client réseau : ce programme nécessite un serveur réseau accessible

// Utilise la librairie GUI controlP5
// Utilise un/des bouton(s) simple(s) (Button)
// Utilise un/des champ(s) texte (Textfield)
// Ajoute un bouton et un champ pour chemin fichier

/*
Envoi une chaine de caractère vers le serveur réseau
à partir champ texte et bouton (libriairie GUI controleP5)
*/


// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

import processing.net.*; // importe la librairie pour connexion réseau Client/Serveur

import controlP5.*; // importe la librairie GUI controlP5
// cette librairie doit être présente dans le répertoire /libraries du répertoire Processing
// voir ici : http://www.sojamo.de/libraries/controlP5/

// déclaration objets

String chaineEnvoiNetwork = ""; // déclare un objet String (chaine de caractère)

// --- objet Client Réseau ---
Client clientNetwork; // déclaration d'un objet client réseau
String inStringFromServerNetwork; // pour réception chaine en provenance Serveur Réseau
String inStringFromClientBoard; // pour réception chaine en provenance carte Arduino Client

// --- police texte ---
//PFont fontA; // crée un objet de police texte

//---- librairie GUI controlP5 ----
ControlP5 controlP5; // déclare un objet principal de la librairie GUI controlP5

Button networkButton; // déclare objet Button  

Textfield networkText; // déclare des objets Textfield

// déclaration variables globales

//------ déclaration des variables de couleur utiles ----
int jaune=color(255,255,0);
int vert=color(0,255,0);
int rouge=color(255,0,0);
int bleu=color(0,0,255);
int noir=color(0,0,0);
int blanc=color(255,255,255);
int bleuclair=color(0,255,255);
int violet=color(255,0,255);

//String ipServeur="192.168.2.5"; // ip du serveur sur réseau wifi local
String ipServeur="192.168.0.3"; // ip du serveur sur réseau wifi local
//String ipServeur="127.0.0.1"; // ip du serveur sur boucle locale

//int portNetwork=12345; // port pour boucle locale
int portNetwork=5905; // port pour réseau wifi
//int portNetwork=80; // port pour réseau http

// XXXXXXXXXXXXXXXXXXXXXX  Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX

void setup(){ // fonction d'initialisation exécutée 1 fois au démarrage

        // ---- initialisation paramètres graphiques utilisés
        colorMode(RGB, 255,255,255); // fixe format couleur R G B pour fill, stroke, etc...
        fill(0,0,255); // couleur remplissage RGB
        stroke (0,0,0); // couleur pourtour RGB
        rectMode(CORNER); // origine rectangle : CORNER = coin sup gauche | CENTER : centre
        imageMode(CORNER); // origine image : CORNER = coin sup gauche | CENTER : centre
        //strokeWeight(0); // largeur pourtour
        frameRate(30);// Images par seconde

        // --- initialisation fenêtre de base ---
        size(400, 130); // ouvre une fenêtre xpixels  x ypixels
        background(vert); // couleur fond fenetre

// --- initialisation des objets et fonctionnalités utilisées ---

        //------------- initialisation de la police texte - à mettre avant série ----
        //fontA = loadFont("Arial-Black-14.vlw"); // charge le fichier police dans l'objet police texte
        // ce fichier doit être présent dans un rép <data> dans le répertoire du programme
        // pour générer un fichier de police à partir des polices système aller dans Tools > create Fonts
        // voir également http://processing.org/learning/text/

        //textFont(fontA, 14); // Initialise la police et sa taille (en pixels)

        //text("Client Processing actif !", 10, 60);


        //======== Initialisation Objets GUI ControlP5 =========

        controlP5 = new ControlP5(this); // initialise l'objet principal de la librairie GUI controlP5

        // typeObjet nomObjet=controlP5.addObjet(paramètres); // pour info : déclaration / initialisation possible en 1 ligne
        // Textfield field = controlP5.addTextfield("myWindowTextfield",70,130,100,20); // exemple

        //======== Initialisation Objets Button =========


        //---- le bouton envoi chaine vers client réseau Processing
        networkButton=controlP5.addButton("networkButton",0,110,35,200,24); // initialise et ajoute un Button au ControlP5
        networkButton.setLabelVisible(true); // affichage des labels
        networkButton.setLabel("==> ENVOI reseau vers serveur " + ipServeur); // fixe label du bouton
        networkButton.setColorActive(color(255,0,0)); // fixe la couleur active
        networkButton.setColorForeground(color(0,255,255)); // fixe couleur avant

        //======== Initialisation Objets Textfield =========


        //---- champ texte saisie chaine
        networkText=controlP5.addTextfield("networkText",10,10,300,20); // initialise et ajoute un Textfield au ControlP5
        networkText.setAutoClear(false); // autoeffacement après return
        networkText.setValue(chaineEnvoiNetwork); // initialise Texte du champ
        networkText.setLabelVisible(true); // affichage des labels
        networkText.setLabel("Saisir chaine"); // fixe label
        networkText.setColorLabel(bleu); // fixe la couleur label
        networkText.setColorActive(color(255,0,0)); // fixe la couleur active
        networkText.setColorForeground(color(0,255,255)); // fixe couleur avant


//------------- 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
  //clientNetwork = new Client(this, ipServeur, portNetwork); // Remplacer avec l'adresse IP du serveur et le numéro de port utilisé
  clientNetwork = new Client(this, ipServeur, portNetwork); // 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

  println("Client : Connexion du client Processing.....");

} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

void  draw() { // fonction exécutée en boucle

     if (clientNetwork.available() > 0) { // si des caractères sont disponibles en provenance du réseau
        inStringFromServerNetwork= clientNetwork.readString();
        println("10.Réception client Processing <== serveur réseau : " + inStringFromServerNetwork);
      }

} // fin de la fonction draw()

// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX


// Gestion des évènements des objets GUI controlP5 ----

//------ fonction gestion globale des évènements GUI controlP5
public void controlEvent(ControlEvent theEvent) {
        //println(theEvent.controller().name());// affiche le nom de l'évènement
}

//---- evenement bouton envoi chaine

void networkButton(int theValue) { // fonction évènement Button de meme nom - reçoit la valeur

        println("Client : Evènement envoiButton");

        //----- envoie la chaine vers le Serveur Réseau ----
        clientNetwork.write(networkText.getText()+"\n"); //--- envoie une chaine vers le Serveur  suivie d'un saut de ligne
        print("3. Envoi Client Processing ==> Serveur Réseau : ");
        print(networkText.getText()+"\n");
        delay(100); // entre deux envois

       networkText.setValue(""); // vide le champ texte


} // fin evènement bouton envoi


// ------ gestion évènement Textfield ------

//---- evenement champ texte network

public void networkText(String theText) { // fonction évènement Textfield de meme nom - déclenché par return - reçoit la chaine

        //println("Evènement CheminText avec valeur = "+theText);

        chaineEnvoiNetwork=theText; // mémorise le contenu du champ

        //println("Le chemin est :"+chaineEnvoi);

} // fin evènement champ texte chemin fichier



//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX
 

12.  Pour aller plus loin...

  • Une fois que ce programme fonctionne en local, vous n'avez qu'à brancher votre carte Arduino + module wifi Redfly sur un autre PC connecté au réseau sur lequel vous ouvrez un terminal et vous devez également voir dans la fenêtre Terminal que la chaine émise a bien été transmise par le réseau wifi.
  • Cette capture d'écran montre le bureau à distance d'un deuxième PC sur lequel est connecté la carte Arduino + module wifi Redfly. L'envoi de chaine de caractère par réseau wifi fonctionne donc très bien !