// — 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 : 20/11/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 ? ———
 /* Serveur Ethernet renvoyant contenu SD-Card lors requete  */
 // Une ligne de donnée est ajoutée dans un fichier de la SD-CARD à intervalle régulier

// — Fonctionnalités utilisées —

// Utilise le module Ethernet Arduino
// en mode serveur HTTP
// Utilise la SD Card

// ——– Circuit à réaliser ———

// Le module Ethernet est à enficher broche à broche sur la carte Arduino
// Connecter broche SCLK du module Ethernet sur la broche 13
// Connecter broche MISO du module Ethernet sur la broche 12
// Connecter broche MOSI du module Ethernet sur la broche 11
// Connecter broche Select Ethernet du module Ethernet sur la broche 10
// Connecter broche Select SD Card du module Ethernet sur la broche 4
// Le module Ethernet est compatible avec la carte Mega via le connecteur ICSP

// /////////////////////////////// 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 <SPI.h>
#include <Ethernet.h>
#include <Server.h>
#include <Client.h>
#include <SD.h> // crée automatiquement un objet racine SD représentant la carte mémoire SD

// — Déclaration des constantes utiles —

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

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

//const int Voie[6]={0,1,2,3,4,5}; //declaration constante de broche analogique

// — Déclaration des variables globales —

boolean flagSerial=true; // pour activation message série
boolean flagNetwork=true; // pour activation message réseau

//=============== SD CARD ================

File myFile; // objet file

char dirName[]=« /monrep »; // tableau de caracteres pour le nom du répertoire sur la SD Card

// nom du fichier court (8 caractères maxi . 3 caractères maxi) (dit format DOS 8.3)
char fileName[] = « test.txt »; // tableau de caractères pour le nom du fichier

char pathFile[] = « /monrep/test.txt »; // tableau de caractères pour le nom du fichier

int test; //variable mémorisation résultat renvoyé par fonctions

long millis0=millis(); // mémorise dernier millis() pris en compte
int intervalle=1000; // intervalle en milliseconde entre 2 mesures

boolean flagLive=false; // drapeau mode « live » = envoie en temps réel des valeurs
boolean flagLiveSent=true; // variable témoin envoi valeur Live

boolean flagInit=false, flagVerif=false, flagClear=false;

//=============== ETHERNET ==================

//— déclaration du tableau d’adresse MAC —
//— ne pas utiliser la meme adresse MAC si on utilise plusieurs module ethernet
//— utiliser adresse MAC indiquée sur étiquette du module
//byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x1A, 0x71 };

//—- tableau de l’adresse IP de la carte Arduino
byte ipLocal[] = { 192,168,1,70 }; // le réseau local a numéro 192.168.1.x
//—- ATTENTION : aucun élément du réseau ne doit avoir la meme adresse IP

// nb : si on utilise un routeur DHCP sur le réseau, il faut simplement que l’adresse statique
// soit « hors » de la plage des adresses dynamiques DHCP

//—– tableau de l’adresse de la passerelle —
byte passerelle[] = { 192, 168, 1, 1 }; // l’adresse du PC de connexion à internet ou de la box

//—– tableau du masque de sous réseau
byte masque[] = { 255, 255, 255, 0 }; // idem masque sous-réseau du PC ou de la box : 255.255.255.0

String requeteRecue=«  »; // variable stockage requete client

//– variables utiles pour la réception des trames de téléinformation
String chaineRecue=«  »; // déclare un string vide global
int comptChar=0; // variable de comptage des caractères reçus
char charIn=0; // variable de mémorisation du caractère courant en réception

int delayRecept=10; // delai en µs pour laisser temps réception caractères à 1200 bauds (débit lent…)
// on utilise delaymicroseconds dans ce programme pour les pauses afin d’éviter problème interruption avec delay()
// NB : à 1200 bauds, un caractère sur 10 bits mets théoriquement 1/120 = 8.33ms pour arriver…  

boolean debug=true; // drapeau activation messages debug

String chaineHtml=«  »;

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

//— création de l’objet serveur —-
// Server serveurHTTP(80); // crée un objet serveur utilisant le port 80 = port HTTP
EthernetServer serveurHTTP(80); // préfixe Ethernet devant Client et Server à partir Arduino 1.0

//Client client;

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

//—- initialise la connexion Ethernet avec l’adresse MAC du module Ethernet, l’adresse IP Locale
//—- l’adresse IP de la passerelle internet et le masque du réseau local
Ethernet.begin(mac, ipLocal, passerelle, masque);
delay(1000); // donne le temps à la carte Ethernet de s’initialiser

//—- initialise le serveur HTTP—-
serveurHTTP.begin(); //—- initialise le serveur HTTP

//— initialise connexion série
Serial.begin(115200); // réinitialise communication série

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

//— gestion initiale de la SD Card —

initSDCard(true, false); // initialisation de la SDCard – crée le fichier de stockage – n’efface pas fichier existant
// la fonction reçoit un drapeau pour begin et un drapeau pour efface – voir ci-dessous

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

//—- Code type pour une connexion d’un client distant au serveur local —

// crée un objet client basé sur le client connecté au serveur HTTP
// Client client = serveurHTTP.available();
EthernetClient client = serveurHTTP.available(); // préfixe Ethernet devant Client et Server à partir Arduino 1.0

////////////////// Connexion au client ///////////////////

  if (client) { // si l’objet client n’est pas vide

    if (client.connected()) { // si le client est connecté

////////////////// Reception de la requete Client ///////////////////

      requeteRecue=«  »; // initialise chaine reception requete

      while (client.available()) { // tant que des octets sont disponibles en lecture

                char c = client.read(); // lit l’octet suivant reçu du client (pour vider le buffer au fur à mesure !)
                requeteRecue=requeteRecue+c; //

      } // — fin while client.available

    // si plus de caractères disponibles = requete client terminée

////////////////// Analyse de la requete client ///////////////////

         Serial.println (« Requete = »);
         Serial.println (requeteRecue);

        //=================== requete initSD ============================

        if (requeteRecue.startsWith(« initSD »)) { // si initialisation de la SDCard demandée – efface pas fichier

            flagInit=false;

            initSDCard(true, false); // initialise SD sans effacer fichier et sans begin

        } // fin requete mode live

        //=================== requete verifSD ============================

        if (requeteRecue.startsWith(« verifSD »)) { // si vérification de la SDCard demandée – efface pas fichier

            initSDCard(false, false); // initialise SD sans effacer fichier et sans begin

            flagVerif=false;

            if ((flagNetwork)||(flagVerif)) {
              client.println (« Carte SD Verifiee! »);
               client.print(« Taille Fichier= »);
                client.print(myFile.size());
                client.println(« Octets »);
            }

            flagVerif=false;

        } // fin requete mode live

        //=================== requete clearSD ============================

        if (requeteRecue.startsWith(« clearSD »)) { // si effacement de la SDCard demandée – vide fichier

            flagClear=false;

            initSDCard(false,true); // vide le fichier sans initialiser SD

            if ((flagNetwork)||(flagClear)) client.println (« Carte SD Effacee! »);

            flagClear=false;

        } // fin requete mode live

        //=================== requete fixDelay(0000) =======================

        if (requeteRecue.startsWith(« fixDelay(« ) ) { // si requete fixDelay( reçue

         if (flagSerial) Serial.println (« Modification du delai de mesure : »);
         if (flagNetwork) client.println (« Modification du delai de mesure : »);

         if (requeteRecue.substring(requeteRecue.length()–2,requeteRecue.length()–1)==« ) ») { // si la chaine se termine par )

         intervalle=stringToLong(requeteRecue.substring(9,requeteRecue.length()–2)); // récupère la valeur entre les ( )
         }

         if (flagSerial) {
           Serial.print(« Nouvel intervalle= »);
           Serial.print (intervalle);
           Serial.println (« ms »);
         }

         if (flagNetwork) {
           client.print(« Nouvel intervalle= »);
           client.print (intervalle);
           client.println (« ms »);
         }

        }        

        //=================== requete stop live ============================

        if (requeteRecue.startsWith(« stopLive »)) { // si arret du mode live demandé

          flagLive=false; // activation du mode live

         if (flagSerial) Serial.println (« Mode live inactif ! »);
         if (flagNetwork) client.println (« Mode live inactif ! »);

        } // fin requete stop live

        //=================== requete mode live ============================

        if (requeteRecue.startsWith(« modeLive »)) { // si debut du mode live demandé

              flagLive=true; // activation du mode live

         if (flagSerial) Serial.println (« Mode live actif ! »);
         if (flagNetwork) client.println (« Mode live actif ! »);

        } // fin requete mode live

        //===================== requete getLive ================================
        // Mode Live : envoi de la dernière valeur mémorisée sur le réseau
        // lorsque le modeLive est activé, Processing envoie une requete à intervalles réguliers
        // pour obtenir un renvoi à intervalle régulier

        if (requeteRecue.startsWith(« valueLive »)) { // si demande de valeur live

            if ((flagLive) && (!flagLiveSent)) { // si mode live activé et que dernière valeur pas envoyée

                Serial.println(millis0);        
                client.println(millis0); // envoie la dernière valeur prise en compte
                flagLiveSent=true; // témoin envoi dernière valeur

              } // fin si flagLive

        } // fin si requete getLive

        //=================== requete lecture carte SD ============================
        if (requeteRecue.startsWith(« lireSD »)) { // si lecture de la SDCard demandée

          //— mettre ici code à exécuter pour cette commande

          //– on envoie tous les caractères du fichier de la SDCard sur le réseau et/ou le port Série
          //– l’analyse du contenu sera faite coté PC dans Processing (plus robuste pour analyse contenu du fichier)

         //— ouverture du fichier en lecture —
          myFile=SD.open(pathFile,FILE_READ); // ouvre le fichier en lecture

         if (flagSerial) Serial.println (« Ouverture du fichier en lecture »);
         if (flagNetwork) client.println (« Ouverture du fichier en lecture »);

         for (int i=0; i<myFile.size(); i++ ) {

           myFile.seek(i); // se positionne à la position i

           if (flagSerial) Serial.print(char(myFile.peek())); // affiche le caractère courant
           if (flagNetwork) client.print(char(myFile.peek())); // affiche le caractère courant            
         }

       myFile.close(); // fermeture du fichier

       if (flagSerial) Serial.println (« Fermeture fichier effectuee! »);
       if (flagNetwork) client.println (« Fermeture fichier effectuee! »);

        } // fin if si « lireSD »

        //=================== requete lecture cart SD format HTML ============================

      if (requeteRecue.startsWith(« GET »)) { // si requete GET = renvoi d’une réponse HTML

/* décommenter si on veut une réponse HTML — attention fait déborder RAM = utiliser mémoire FLASH au besoin

        // —– envoi d’une entete standard de réponse http
          client.println(« HTTP/1.1 200 OK »);
          client.println(« Content-Type: text/html »);
          client.println(« Connection: close »); // pour connexion non persistante client
          client.println();

        // —– envoi du code HTML de la page

             //—- debut de la page HTML —
             client.println(« <html> »);

             // —- Entete de la page HTML —-
             client.println(« <head> »);

               client.println(« <meta content=\ »text/html; charset=ISO-8859-1\ » http-equiv=\ »Content-Type\ »> »);

               client.println(« <title>Connexion au Serveur Arduino</title> »);

               // balise meta pour réactualisation automatique de la page Web toutes les n secondes
               client.println(« <META HTTP-EQUIV=\ »Refresh\ » CONTENT=\ »5\ »> »);

             client.println(« </head> »);

             //—– Corps de la page HTML —
             client.println(« <body> »);

             client.println(« <br> »);
             client.println(« ****** Contenu du fichier de la SD-CARD **** »);
             client.println(« <br> »);

          //– on envoie tous les caractères du fichier de la SDCard sur le réseau et/ou le port Série
          //– l’analyse du contenu sera faite coté PC dans Processing (plus robuste pour analyse contenu du fichier)

         //— ouverture du fichier en lecture —
          myFile=SD.open(pathFile,FILE_READ); // ouvre le fichier en lecture

         if (flagSerial) Serial.println (« Ouverture du fichier en lecture »);
         if (flagNetwork) client.println (« Ouverture du fichier en lecture »);

         for (int i=0; i<myFile.size(); i++ ) {

           myFile.seek(i); // se positionne à la position i

           if (myFile.peek()==13) { // si saut de ligne = on remplace par <br>

             if (flagSerial) Serial.println(« <br> »); // affiche le caractère courant
             if (flagNetwork) client.println(« <br> »); // affiche le caractère courant            

           }
           else { // si pas de saut de ligne = on affiche le caractère lui-meme

             if (flagSerial) Serial.print(char(myFile.peek())); // affiche le caractère courant
             if (flagNetwork) client.print(char(myFile.peek())); // affiche le caractère courant  

           } // fin else        

       } // fin for i

       myFile.close(); // fermeture du fichier

       if (flagSerial) Serial.println (« Fermeture fichier effectuee! »);
       if (flagNetwork) client.println (« Fermeture fichier effectuee! »);

             client.println(« <br> »);

             client.println(« </body> »);

             //—- fin de la page HTML
             client.println(« </html> »);

*/
      } // fin if GET

    } // — fin if client connected

    delay(1);
    // on donne au navigateur le temps de recevoir les données

////////////////// Fermeture de la connexion client ///////////////////

     client.stop(); // ferme le client distant une fois réponse envoyée
    delay(10); // laisse temps fermeture

  } //—- fin if client existe —-

//—— écriture d’une valeur dans la SD-card à intervalle régulier ——

if ((millis()–millis0)>intervalle) { // si intervalle écoulé : écriture dans la SDCARD

  millis0=millis(); // mémorise nouveau millis()

      //—– ouverture du fichier pour écriture —

    myFile=SD.open(pathFile,FILE_WRITE); // ouvre le fichier en écriture et crée fichier si existe pas

     if (myFile!=true) Serial.println (« Echec ouverture fichier ! »);  // si échec ouverture
     else { // si ouverture réussie

       //Serial.println (« Ouverture fichier reussie ! »);

       myFile.seek(myFile.size()); // positionnement à la fin du fichier

       //Serial.println (« Positionnement a la fin du fichier! »);

        //myFile.println(); // ajoute un saut de ligne

      //myFile.println(« —— Debut nouvel enregistrement ——-« ); // ajoute une ligne

       myFile.print(« millis= »);  myFile.println(millis());  
       //— mettre ici toute valeur voulue à écrire en SD CARD      

       myFile.close(); // fermeture du fichier

       //Serial.println (« Fermeture fichier effectuee! »);
       Serial.print (« . »); // temoin enregistrement d’une valeur

       //— gestion drapeau du mode live —

       if (flagLive) { // si mode live activé

          flagLiveSent=false; // valeur pas envoyée          

       }// si flagLive

     } // fin else     = ouverture réussie

} // fin if millis()

delay(10); // entre 2 passages loop

//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 SD CARD ===============================

//————— Initialisation de la SDCard ———

void initSDCard(boolean flagBegin, boolean flagErase) {
  // la fonction reçoit un drapeau pour begin et un drapeau pour efface
  // reçoit en paramètre drapeau pour activation begin (seulement première fois
 // reçoit en paramètre true/false pour effacement fichier

  pinMode(10, OUTPUT); // laisser la broche SS en sortie – obligatoire avec librairie SD

  if (flagBegin==true) { // si flag Begin==true

   //—– initialisation de la carte SD —–
  Serial.println(« Initialisation de la SD card… »);

    test=SD.begin(4); // initialisation de la carte SD avec broche 4 en tant que CS – renvoie true/false

    if (test!=true) { // si initialisation n’est pas réussie
      Serial.println(« Echec initialisation! »); // message port Série
    }
    else { // si nitialisation réussie
      Serial.println(« Initialisation reussie ! »); // message port Série
    } // fin si SD.begin
  }

  //—– test de l’existence d’un fichier

 test=SD.exists(pathFile); // test si le fichier existe – renvoie true/false

 Serial.print (« Test= »); Serial.println(test);

 if (test!=true) { // si le fichier n’existe pas

   Serial.println (« Le fichier n’existe pas ! »);

       //—– création du fichier —

    myFile=SD.open(pathFile,FILE_WRITE); // ouvre le fichier en écriture et crée fichier si existe pas

     if (myFile!=true) Serial.println (« Echec ouverture fichier ! »);  // si échec ouverture
     else { // si ouverture réussie

       Serial.println (« Ouverture fichier reussie ! »);

       myFile.println(« Test fichier »);

       myFile.close(); // fermeture du fichier

       Serial.println (« Fermeture fichier effectuee! »);

     }    // fin ouverture réussie      

      //—- Vérification existence du fichier

       test=SD.exists(pathFile); // test si le fichier existe – renvoie true/false

       Serial.print (« Test= »); Serial.println(test);

       if (test!=true)   Serial.println (« Le fichier existe pas ! »); // si fichier existe pas
       else { // si fichier existe

         Serial.println (« Creation fichier OK ! »);

     } // fin else = fichier existe

 } // fin si rép existe pas

 else { // si le fichier existe

     Serial.println (« Le fichier existe ! »);

     if (flagErase==true) { // si flagErase==true : le fichier est effacé
       SD.remove(pathFile); // efface le fichier  
       Serial.println (« Fichier efface ! »);  
       flagClear=true; // drapeau témoin
     }
     else { // si flagErase false = le fichier n’est pas effacé
       Serial.print(« Taille Fichier= »);
       Serial.print(myFile.size());
       Serial.println(« Octets »);
       flagVerif=true; // drapeau témoin

     } // fin si flagErase false  

 }// fin else si fichier existe pas

} // ————- fin initSD ————

//————— Lecture SD CARD ——

// void lectureSDCard(boolean flagSerial, boolean flagNetwork, Client clientIn) {
void lectureSDCard(boolean flagSerial, boolean flagNetwork, EthernetClient clientIn) {
// préfixe Ethernet devant Client et Server à partir Arduino 1.0

      //—- lecture du fichier

/*      
       test=SD.exists(pathFile); // test si le fichier existe – renvoie true/false

       Serial.print (« Test= »); Serial.println(test);

       if (test!=true)   Serial.println (« Le fichier existe pas ! »); // si fichier existe pas
       else { // si fichier existe

         Serial.println (« Le fichier existe ! »);
 */

         //— ouverture du fichier en lecture —
          myFile=SD.open(pathFile,FILE_READ); // ouvre le fichier en lecture

         if (flagSerial) Serial.println (« Ouverture du fichier en lecture »);
         if (flagNetwork) clientIn.println (« Ouverture du fichier en lecture »);

         for (int i=0; i<myFile.size(); i++ ) {

           myFile.seek(i); // se positionne à la position i

           if (flagSerial) Serial.print(char(myFile.peek())); // affiche le caractère courant
           if (flagNetwork) clientIn.print(char(myFile.peek())); // affiche le caractère courant            
         }

       myFile.close(); // fermeture du fichier

       if (flagSerial) Serial.println (« Fermeture fichier effectuee! »);
       if (flagNetwork) clientIn.println (« Fermeture fichier effectuee! »);

       //} // fin else si fichier existe

} // — fin lecture SDCard

// ———- fonction de conversion d’un String numérique en long

long stringToLong(String chaineLong) { // fonction conversion valeur numérique String en int

    long nombreLong=0; // variable locale
    int valeurInt=0; // variable locale

    for (int i=0; i<chaineLong.length(); i++) { // défile caractères de la chaine numérique

      valeurInt=chaineLong.charAt(i); // extrait le caractère ASCII à la position voulue – index 0 est le 1er caractère
      valeurInt=valeurInt–48; // obtient la valeur décimale à partir de la valeur ASCII  

     if (valeurInt>=0 && valeurInt<=9) { // si caractère est entre 0 et 9
       nombreLong=(nombreLong*10)+valeurInt;
     } // fin si caractère est entre 0 et 9

    } // fin for défile caractères

 return (nombreLong); // renvoie valeur numérique

} // ———- fin stringToLong ————

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