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