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 |

SD Card : Enregistrement simple d'une mesure analogique à l'aide d'une carte SD et affichage graphique du fichier obtenu dans un tableur.

Par X. HINAULT - Page créée le : 18/02/2012.

1.  Présentation

  • Ce programme permet de réaliser 1000 mesures analogiques à intervalle régulier et d'enregistrer le résultat dans une SD-Card : les bases des applications de datalogging (enregistrement de données) sont ainsi posées !
  • Les données sont enregistrées dans un fichier texte au format dit "CSV", les valeurs étant séparées par un ;

Une fois de plus, toute la puissance du langage Arduino apparaît ici : pour écrire des données sur la SD-Card, on utilise tout simplement l'instruction file.print() ou file.println(), tout comme on le ferait pour afficher des messages dans le Terminal Série !

  • Ensuite, les données obtenues sont directement utilisables dans un tableur pou réalisation d'un graphique et donc toute utilisation ultérieure dans un document, etc...
  • Ensuite, on peut réutiliser ce graphique et les données sous toutes les formes de son choix. En résumé : on enregistre les données avec la carte Arduino sur une SD-Card, on les récupère dans un tableur, on fait tout ce qu'on veut avec ! Simple, souple : qui dit mieux ?

Ce programme utilise les fonctionnalités suivantes :

  • Utilise la connexion série vers le PC
  • Utilise le module Ethernet Arduino (uniquement pour le connecteur SD Card)

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 SD - pour utiliser une SD Card

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é

  • un module Arduino Ethernet ou tout autre module disposant d'un emplacement pour carte mémoire SD.
  • une carte mémoire micro-SD
  • une résistance variable,

3.  Instructions de montage

  • 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
  • On connectera la résistance variable sur la broche analogique 0.

4.  Le circuit du montage

Le schéma du montage à réaliser (cliquer pour agrandir)

5.  Explication du programme

  • Ce programme initialise la SD Card et ouvre le répertoire racine.
  • Ensuite, un fichier appelé data.txt est créé et ouvert en écriture
  • Une boucle réalise 1000 mesures analogiques
  • Les données sont écrites dans la SD-CARD au fur et à mesure.
  • Le déroulement des opérations est affiché dans un Terminal Série

6.  Mise en oeuvre du programme

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

6.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 :

6.3  Fonctionnement

  • Ouvrir le Terminal Série : on obtient une série de message témoins du déroulement des opérations.
  • Lors de la phase d'enregistrement, faire varier la valeur de la résistance variable !

6.4  Procédure pour récupérer les données d'enregistrement dans un tableur.

  • Une fois l'enregistrement terminé, enlever la SD-Card de son emplacement et la connecter au PC. Ouvrir la carte SD et ouvrir le fichier data.txt qui doit être présent dessus. On obtient un affichage du type :
  • A partir de là, copier l'ensemble du fichier texte dans le presse-papier. Puis ouvrir le tableur de la suite open source Libre Office. Faire "coller" : le fenêtre suivante s'ouvre :
  • Sélectionner ; en tant que séparateur puis valider. Ensuite, on obtient les données dans le tableur sous la forme :
  • A partir de là, on peut faire ce que l'on veut avec les données obtenues, et notamment créer un graphique. Voici par exemple le graphique obtenu avec l'enregistrement de 1000 mesures analogiques en faisant varier la résistance variable :
  • Ensuite, on peut réutiliser ce graphique et les données sous toutes les formes de son choix. En résumé : on enregistre les données avec la carte Arduino sur une SD-Card, on les récupère dans un tableur, on fait tout ce qu'on veut avec ! Simple, souple : qui dit mieux ?

7.  Le programme complet en langage Arduino

A copier/coller directement dans l'éditeur Arduino


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