// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 18/02/1012

// ——- 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 teste le stockage de valeurs issues
de mesures analogiques dans un fichier
sur carte mémoire micro-SD
Données au format CSV pour utilisation directe
dans un tableur OpenOffice.  */

// — Fonctionnalités utilisées —

// Utilise la connexion série vers le PC
// Utilise la conversion analogique numérique 10 bits
// Utilise une carte mémoire micro-SD avec le module Ethernet Arduino
// Utilise une fonction permettant de connaitre la RAM restant disponible

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

// La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)

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

// Broche 14 : Une résistance variable de 10 KOhms

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

const int brocheSDCardSelect=4; // broche utilisée pour sélectionner la SD card

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

const int analog0= A0; // Constante pour la broche analogique 0

// — Déclaration des variables globales —

int mesure_brute=0;// Variable pour acquisition résultat brut de conversion analogique numérique
float mesuref=0.0;// Variable pour calcul résultat décimal de conversion analogique numérique

int test; // Variable utilisée pour tester valeur renvoyée par fonctions SD Card

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

/*
Sd2Card card; // création d’un objet Sd2Card
SdVolume volume; // création d’un objet SdVolume
SdFile root; // création d’un objet SdFile pour le répertoire racine
SdFile file; // création d’un objet SdFile pour le fichier utilisé
*/

File file; // objet file
File root; // objet root pour le répertoire racine

// ////////////////////////// 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(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission

//—- initialise l’utilisation de la carte mémoire SD en mode SPI  
pinMode(10, OUTPUT); // met la broche 10 (SS) en sortie (nécessaire avec module ethernet)
digitalWrite(10, HIGH); // mais désactive le  circuit intégré W5100 du module ethernet!

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

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

  test=SD.begin(brocheSDCardSelect); // 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

  //—– affiche le contenu du répertoire

  root = SD.open(« / »); // ouvre la SD Card à la racine

  Serial.println(« Repertoire racine ouvert ! »);

  } // fin si initialisation réussie

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

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

  //—- efface fichier au préalable —
  test=SD.remove(« data.txt »); // efface fichier et mémorise résultat opération  
  if (test) Serial.println(« Fichier efface »); // affiche message si fichier bien effacé

  //—- crée fichier en écriture —
  file = SD.open(« data.txt », FILE_WRITE); // ouvre le fichier en écriture
  // NB : le fichier est créé si il n’existe pas !

  //—- test si fichier dispo en écriture
  if (!file) { // si fichier pas dispo

    Serial.println (« Erreur ouverture fichier ! »);

  } // fin if

  else { // si le fichier existe et est ouvert

    Serial.println (« Fichier pret pour ecriture ! »);

    //—– Ecriture dans le fichier au format CSV —–

    // premiere ligne du fichier CSV – entete avec liste des champs
    file.println(« NumeroMesure;ValeurBrute;ValeurFloat;Millis »);

    Serial.println (« Enregistrement en cours : »);

    for (int i=0; i<1000; i++) { // n mesures CAN

      // acquisition conversion analogique numérique (100µs env.) sur broche analogique indiquée
      mesure_brute= analogRead(A0) ;

      // calcul tension en Volts
      mesuref=mesure_brute*5.0;
      mesuref=mesuref/1023.0;

      // valeur premier champ
      file.print(i), file.print(‘;’);

      // valeur deuxieme champ
      file.print(mesure_brute), file.print(‘;’);

      // valeur troisieme champ
      file.print(mesuref), file.print(‘;’);

      // valeur quatrieme champ
      file.print(millis());

      // le dernier champ doit se terminer par un saut de ligne +++
      file.println();

      delay(10); // entre chaque mesure
      if ((i+1)%50) Serial.print(« . »); else  Serial.println(« . »);// affiche ligne de 50 points

    } // fin boucle for

    file.close(); // ferme le fichier
    Serial.println(« Fin enregistrement ! »);  
    Serial.println(« Fermeture fichier ! »);  

    Serial.println(« Retirez SD-Card et la lire sur le PC ! »);  

  } // fin else

  while(1); // stoppe loop

} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************