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