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 la connexion du shield Arduino wifi RedFly de chez Watterott au réseau sans fil.

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

(cliquer sur l'image pour agrandir)

1.  Présentation

Ce programme réalise un simple test de connexion au réseau sans fil (http - port 80) à l'aide du shield Arduino wifi RedFly de chez Watterott.

L'intérêt ici est la prise en main du module, avec l'utilisation des fonctions permettant d'obtenir des informations sur le réseau disponible, l'adresse MAC du module, etc...

Ce programme permet de s'assurer que le module fonctionne bien et que la connexion au réseau wifi se fait bien.

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.
  • 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

Ce serveur est accessible depuis un navigateur sur tout PC du réseau wlan local.

  • Une fois la carte programmée, ouvrir le Terminal série en 9600 bauds et faire un reset sur la carte, ce qui doit donner quelque chose comme çà :

(cliquer sur l'image pour agrandir)

  • Tous les messages commençant par AT+RSI correspondent aux messages de communication entre le module wifi Redfly et la carte Arduino.

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 : 14/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 une simple connexion wifi sur port http (port 80) du shield Arduino wifi RedFly de chez Watterott.
*/


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


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

byte http=0xFF; // identifiant de ligne réseau
int http_len=0; // réception len
char http_buf[512]; // buffer de réception

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

    //------------- Connexion au réseau détecté ---------------
    //ret = RedFly.join("belkin54g", "ADB48F70ExxxxxA8D90E",INFRASTRUCTURE); //"wlan" (SSID=nom), "12345678" (clé wep ou wap), INFRASTRUCTURE or IBSS_JOINER
    //ret = RedFly.join("Livebox-f0c2", "FAD994AxxxxxDC1933F5",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 ------------

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

          if(http == 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 !");

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

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

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