e carte d’extension (« shield l’heure et la date Pour cela ... · Fondé(e) sur une œuvre à...

Le Data logging est une carte d’extension (« shield ») qui donne l’heure et la date et qui

permet surtout de sauvegarder des données dans un carte SD, il est basé sur une liaison I2C.

Pour cela vous aurez besoin d’une carte SD formaté en FAT16 ou FAT32, de libraire(s) : RTC

pour la gestion du temps et SD pour la gestion de la carte SD.

Dans cette présentation nous verrons les utilisations possibles de ce shield grâce à quelques

exemples, puis nous verrons ensemble les composants de ce shield, ensuite nous verrons

comment connecter ce shield à votre Carte Arduino, et enfin je vous montrerai comment

vous servir de ce Shield. Mais tout d’abord je vous rappellerai quelques notions sur le Bus

I2C.

ISN-DATA LOGGING TUTORIAL 05/03/2014

Cette œuvre de Bezamat Jérémy est mise à disposition selon les termes de la

licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International.

Fondé(e) sur une œuvre à http://learn.adafruit.com/adafruit-data-logger-shield/.

I- Le bus I2C pages 3-4

II- Utilisations possibles page 5

III- Composition du shield page 6

IV- Connectique pages 7-10

1) Pour Arduino Uno page 7

2) Pour Arduino Mega pages 7-10

V- Programmation pages 11-18

1) Premier programme : Réglage de l’horloge pages 11-12

2) Configuration de la carte SD pages 13-14

3) Ecriture et lecture dans la Carte SD pages 14-15

4) Petit programme de lecture de la température et écriture dans la

carte SD pages 15-17

VI- Annexes pages 18-25

http://creativecommons.org/licenses/by-nc-sa/4.0/deed.fr

http://learn.adafruit.com/adafruit-data-logger-shield/





I2C est un bus de données (un système de communication entre les composants), il a été

conçu par Philips il permet de relier facilement à un microprocesseur différents circuits,

capteur, shield… On peut le retrouver également sous le nom de TWI (Two Wire Interface).

Le bus I2C est un bus de données synchrone bidirectionnel half-duplex (permet la

communication dans les deux sens mais pas simultanément).

La connexion ce fait entre un maître et un ou plusieurs esclaves. Les données sont toujours

envoyées à l’initiative du maître.

La connexion est réalisée par l'intermédiaire de 2 lignes :

SDA (Serial Data Line) : ligne où circulent les données

SCL (Serial Clock Line) : ligne d'horloge

Sur la carte Arduino Uno les ports sont : A4 (SDA), A5 (SCL)

Sur la carte Arduino Mega les ports sont : 20 (SDA), 21 (SCL)

ICI



http://fr.wikipedia.org/wiki/Philips

http://fr.wikipedia.org/wiki/Microprocesseur

http://fr.wikipedia.org/wiki/Synchrone

http://fr.wikipedia.org/wiki/Duplex_%28canal_de_communication%29





#include <Wire.>

Il faut également une masse commune entre les composants.

Pour Arduino vous aurez également besoin d’importer la bibliothèque Wire, déjà installée

dans l’IDE Arduino, par la commande suivante :

1-

Vous avez maintenant les bases de la communication par bus I2C, le shield Data Logging ne

requièrera pas beaucoup plus de connaissance sur l’I2C car la librairie RTC fera le travail à

votre place ! Cependant si vous voulez en savoir plus sur le Bus I2C vous pouvez vous allez

voir ce tutorial : http://mchobby.be/wiki/index.php?title=Arduino_I2C_Intro

Ou encore : http://fr.wikipedia.org/wiki/I2C

Voyons maintenant ensemble quelques exemples d’utilisations du shield Data Logging et les

possibilités qu’offre ce shield.



http://mchobby.be/wiki/index.php?title=Arduino_I2C_Intro

http://fr.wikipedia.org/wiki/I2C





Ce shield vous permettra de créer pas mal de petits programmes. Il vous permettra de sauvegarder

des données dans une carte SD est de mettre l’heure sur des données sans que votre carte Arduino

soit reliée à votre pc.

Vous pouvez par exemple en reliant ce shield avec quelques capteurs obtenir une liste de résultats

datés directement dans votre carte SD. Je vous expliquerai après dans la partie 5 comment le faire

avec un capteur de température. Pour tester ce shield j’ai réalisé le même

montage qu’avec le capteur de température et j’y ai rajouté un capteur

d’humidité, j’ai ensuite branché le tout grâce à un adaptateur usb/ secteur

comme celui-ci :

J’ai effectué le test pendant 24h avec une mesure toutes les 30 secondes et

j’ai pu après quelques petits problèmes en ressortir le graphique suivant :







Je ne rentrerai pas totalement dans les détails de la composition de ce shield car nous n’en

n’auront pas besoin dans ce cours, cependant si vous voulez en savoir plus vous pouvez aller

voir cette page (en anglais évidemment !) : http://learn.adafruit.com/adafruit-data-logger-

shield/shield-overview .

Ce shield est composé d’une horloge en temps réel (RTC , real time clock) que l’on peut voir

en haut à gauche. Au-dessus de la RTC vous pouvez voir une petite pile qui fait office de

batterie de secours qui permet de garder en mémoire la date et l’heure.

Au milieu gauche vous pouvez voir la led POWER, elle vous avertira que le shield est bien

alimenté (en 3,3V).

Ensuite tout en haut au milieu vous pouvez voir le support de la carte SD, c’est là que vous

insèrerez votre carte SD (jusqu’à 32 GO).



http://learn.adafruit.com/adafruit-data-logger-shield/shield-overview

http://learn.adafruit.com/adafruit-data-logger-shield/shield-overview





1) Pour Arduino Uno

Pour connecter le DATA LOGGING à votre Arduino Uno c’est très facile, il vous suffira de

mettre la shield au-dessus de la carte Arduino comme ceci :

2) Pour Arduino Mega

Pour une carte Arduino Mega la connexion est un peu plus complexe, en effet ce shield à été

fait pour une carte Arduino Uno, certaines broches ne sont donc pas placées au même

endroit. Commencer par mettre le shield sur l’avant de la carte Arduino Mega comme avec

la Uno, en vérifiant que le 5v, le 3v, les masses soit au bon endroit.







Comme ceci :

Ensuite branchez deux fils des broches 4 et 5 du shield vers les broches 20 (SDA) à 21(SCL) de

l’Arduino. Comme ceci :

Après il faut brancher les broches 13, 12, 11, 10 du shield vers les broches 52, 50, 51, 53 de

l’Arduino comme ceci :







Voici un tableau récapitulatif :

Arduino Mega Data logging SDA 20 4 SCL 21 5

52 (sck) 13

50(Miso) 12 51(Mosi) 11

53(SS) 10







Au final vous devriez arriver à ça :

Voilà maintenant votre shield bien relié à votre carte Arduino nous pouvons donc passer à la

partie programmation ! Mais avant n’oubliez pas d’installer la librairie RTC disponible ici :

http://learn.adafruit.com/adafruit-data-logger-shield/downloads (à glisser dans votre

dossier librairies situer normalement dans vos document/Arduino)



http://learn.adafruit.com/adafruit-data-logger-shield/downloads





Maintenant que vous avez quelques bases en I2C et que vous avez bien branché votre Data

Logging nous pouvez rentrer dans le vif du sujet avec la partie programmation !

Tous les programmes que j’expliquerai par la suite sont disponibles et commentés dans le fichier joint

ou dans l’annexe du document.

1) Premier programme : Réglage de l’horloge

Je vais vous montrer tout d’abord comment régler et afficher l’heure, en effet le data logging

à besoin d’être réglé. Vous pouvez le constater en entrant ce petit programme, je vous

l’expliquerai par la suite :







Une fois le programme envoyé sur la carte Arduino ouvrez le moniteur série, réglez le baud à

57600 en bas de l’écran et vous devriez voir quelque chose comme ça :

Vous voyez en effet que la date n’est pas la bonne et l’heure non plus. Enlevez maintenant

les « // » devant la commande RTC.adjust(DateTime(__DATE__, __TIME__)); et relancez le

programme … Et voilà maintenant l’horloge est réglée.

Expliquons maintenant ce programme :

-Au début vous voyez deux includes, ils permettent d’appeler les deux bibliothèques :

RTClib, la bibliothèque qui permet de gérer le shield et Wire qui est utilisé par RTClib.

-RTC_DS1307 RTC; permet de dire à votre PC avec quel shield vous travaillez : ici le

RTC_DS1307.

-Dans le Setup() nous démarrons les différentes communications par où vont circuler les

données, wire.begin() pour la liaison I2C, RTC.begin() pour communiquer avec la

bibliothèque RTC et enfin Serial.begin() que vous connaissez normalement pour démarrer la

communication avec le moniteur série. Il y a ensuite dans le setup la commande

RTC.adjust(DateTime(__DATE__, __TIME__)); pour régler la date et l’heure comme vu au-

dessus.

-Dans le loop(), la commande DateTime now = RTC.now(); sert à aller chercher l’heure

actuelle dans le shield. Toutes les commandes suivantes servent à afficher l’année, l’heure,

etc... Dans le moniteur série comme la commande : Serial.print(now.year()); qui affiche

l’année.

Vous pouvez également voir l’heure qu’il sera dans le futur, par exemple dans 10 jour et 30

secondes : DateTime future (now.unixtime() + 10 * 86400L + 30); Pour aller chercher l’heure

future (86400 car 60*60*24 secondes dans une journée) Puis pour afficher faites comme

pour avant mais avec future.day maintenant comme ceci : Serial.print(future.day());

Passons maintenant à la configuration de votre carte SD !







2) Configuration de la carte SD

Tout d’abord il faut que vous formatiez votre carte SD si ce n’est pas déjà fait vous pouvez

rechercher sur internet comment faire ou aller directement ici :

http://learn.adafruit.com/adafruit-data-logger-shield/using-the-real-time-clock-1

Voilà maintenant que vous avez une carte SD configurée et insérée dans le shield nous

pouvons commencer.

Dans un premier temps ouvrez le programme CardInfo, soit par le fichier joint soit en

ouvrant celui déjà normalement intégré dans votre IDE Arduino comme ceci :








Je ne vous expliquerai pas ce programme car il n’a pas réellement d’intérêt, et il est très bien

commenté. Il permet seulement de vérifier que votre Carte Arduino voit bien la carte SD, vous

devriez arriver à quelque chose qui ressemble à cela :

Vous pouvez rencontrer de nombreux problèmes à l’exécution de ce programme surtout pour les

cartes Arduino Mega. Vérifiez tout d’abord si votre carte SD est bien formatée, si tous les câbles sont

bien branchés. Si le problème persiste essayez de vous rendre ici http://learn.adafruit.com/adafruit-

data-logger-shield/using-the-real-time-clock-1 et de suivre toute les étapes pour bien installer votre

carte SD.

3) Ecriture et lecture dans la Carte SD

Dans cette partie nous allons faire un petit programme pour voir comment on écrit dans une

carte SD puis comment lit-on dans une carte SD.

Ouvrer le programme : Ecriture_lecture_carte_SD

Le programme est normalement assez bien commenté et compréhensible, prenez le temps

de bien le comprendre et faites des essais par vous-mêmes. Je vous donne ici les trois

méthodes principales pour utiliser une carte SD : Ecrire avec log_test

=SD.open("log_test.txt", FILE_WRITE); Lire avec log_test=SD.open("log_test.txt"); et

supprimer avec SD.remove("log_test.txt");









Vous devriez en exécutant ce programme arriver à ça :

4) Petit programme de lecture de la température et écriture dans

la carte SD

Je vous donne un exemple d’un petit programme qui permet de stocker dans la carte SD des

températures à l’aide d’un capteur de température :

GND

Données

5V







Commencez tout d’abord par relier votre carte Arduino au capteur de température, le

capteur envoie des données entre 0 et 1023 il faut donc le brancher sur une entrée

analogique, moi je l’ai mis sur le port A11 de ma carte Arduino Mega, branchez également le

5v et n’oubliez pas la masse ! Voilà ce que ça donne :

Maintenant vous pouvez ouvrir le programme ecriture_SD_temperature.

Ce programme fonctionne exactement comme le précèdent mise à part la lecture de la

valeur du capteur de température qui mérite quelques explications :

Dans ma boucle principale j’appelle la fonction qui va lire la valeur renvoyée par le capteur

par la commande : float temperature = fonction_temperature();

Dans cette fonction (fonction_temperature) qui renvoit un float (nombre a virgule), on prend

la valeur renvoyée par le capteur grâce à la commande analogRead(capteur_temperature);

et on la stocke dans valeur_capteur_temperature. Ensuite je transforme cette valeur qui

était comprise entre 0 et 1023 en valeur correspondant à la tension (entre 0 et 5V) et je

stocke cette nouvelle valeur dans T1. Ensuite j’enlève 0.4 à T1 car le 0°C est à 0.4v et non pas

à 0V (ce qui permet une température négative), et je divise le tout par 0.0195 car le pas et

de 0.0195 (+1°C = +0.0195V). Au final je renvoie la valeur température et voilà.

Le capteur de

température Le port

A11

La masse

et le 5V







Vous devriez au final arriver à ça :

Vous pouvez maintenant mettre votre carte SD sur un port SD de votre ordinateur et vous y

verrez le fichier RESULTAT.txt contenant ceci :







Voilà, j’espère que ce cour vous aura été utile. Je remercie les professeurs d’ISN du lycée

Maurice Janetti pour m’avoir fourni le matériel et leurs conseils et Laura Martinez pour

m’avoir aidé pour la mise en forme des résultats et du graphique Excel.

Bezamat Jérémy Terminale S-SI







#include <Wire.h> // On importe la librairies Wire

#include <RTClib.h> // On importe la librairies RTClib

RTC_DS1307 RTC; // On indique le type de composant utilisé

void setup () {

Serial.begin(57600);// Debut de la communication série

Wire.begin(); // Debut de la communication I2C

RTC.begin(); // Debut de la communication a partir de la librairie RTC

//RTC.adjust(DateTime(__DATE__, __TIME__)); // Reglage de l'horloge grâce au PC

}

void loop () {

DateTime now = RTC.now(); // Recherche de la date, heure, grâce a la librairie I2C

Serial.print(now.year()); // Affichage dans le Moniteur série l'année

Serial.print('/');

Serial.print(now.month());// Affichage dans le Moniteur série le mois

Serial.print('/');

Serial.print(now.day()); //Affichage dans le Moniteur série le jour

Serial.print(' ');

Serial.print(now.hour());// Affichage dans le Moniteur série l'heure

Serial.print(':');

Serial.print(now.minute());// Affichage dans le Moniteur série les minutes

Serial.print(':');

Serial.print(now.second());// Affichage dans le Moniteur série les secondes

Serial.println();

Serial.println();

delay(3000);

}

Réglage de l’horloge







#include <SPI.h>

#include <SD.h> // set up variables using the SD utility library functions: Sd2Card card; SdVolume volume; SdFile root; // change this to match your SD shield or module; // Arduino Ethernet shield: pin 4 // Adafruit SD shields and modules: pin 10 // Sparkfun SD shield: pin 8 const int chipSelect = 10; void setup() { // Open serial communications and wait for port to open: Serial.begin(9600); while (!Serial) { ; // wait for serial port to connect. Needed for Leonardo only } Serial.print("\nInitializing SD card..."); // On the Ethernet Shield, CS is pin 4. It's set as an output by default. // Note that even if it's not used as the CS pin, the hardware SS pin // (10 on most Arduino boards, 53 on the Mega) must be left as an output // or the SD library functions will not work. pinMode(SS, OUTPUT); // we'll use the initialization code from the utility libraries // since we're just testing if the card is working! while (! card.init (SPI_HALF_SPEED, 10, 11, 12, 13)) { Serial.println("initialization failed. Things to check:"); Serial.println("* is a card is inserted?"); Serial.println("* Is your wiring correct?"); Serial.println("* did you change the chipSelect pin to match your shield or module?"); } // print the type of card Serial.print("\nCard type: "); switch(card.type()) { case SD_CARD_TYPE_SD1: Serial.println("SD1"); break; case SD_CARD_TYPE_SD2: Serial.println("SD2");

Configuration de la carte SD







break; case SD_CARD_TYPE_SDHC: Serial.println("SDHC"); break; default: Serial.println("Unknown"); } // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32 if (!volume.init(card)) { Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card"); return; } // print the type and size of the first FAT-type volume uint32_t volumesize; Serial.print("\nVolume type is FAT"); Serial.println(volume.fatType(), DEC); Serial.println(); volumesize = volume.blocksPerCluster(); // clusters are collections of blocks volumesize *= volume.clusterCount(); // we'll have a lot of clusters volumesize *= 512; // SD card blocks are always 512 bytes Serial.print("Volume size (bytes): "); Serial.println(volumesize); Serial.print("Volume size (Kbytes): "); volumesize /= 1024; Serial.println(volumesize); Serial.print("Volume size (Mbytes): "); volumesize /= 1024; Serial.println(volumesize); Serial.println("\nFiles found on the card (name, date and size in bytes): "); root.openRoot(volume); // list all files in the card with date and size root.ls(LS_R | LS_DATE | LS_SIZE); } void loop(void) { }







#include <SD.h> // On importe la librairies SD #include <SPI.h> // On importe la librairies SPI #include <Wire.h> // On importe la librairies Wire #include <RTClib.h>// On importe la librairies RTClib RTC_DS1307 RTC; // change this to match your SD shield or module; // Arduino Ethernet shield: pin 4 // Adafruit SD shields and modules: pin 10 // Sparkfun SD shield: pin 8 const int chipSelect = 10; File log_test; void setup() { Serial.begin(57600); Wire.begin(); // Debut de la communication I2C RTC.begin(); // Debut de la communication a partir de la librairie RTC RTC.adjust(DateTime(__DATE__, __TIME__));// Reglage de l'horloge grâce au PC while (!Serial) { ; // wait for serial port to connect. Needed for Leonardo only } Serial.print("Initializing SD card..."); pinMode(51, OUTPUT); // pin pour communication avec la carte SD if (!SD.begin()) { Serial.println("initialization failed!"); return; } Serial.println("initialization done."); // on supprime le fichier si il existe déjà if (SD.exists("log_test.txt")) { Serial.println("Removing log_test.txt..."); SD.remove("log_test.txt"); } //Premier partie Ecriture: log_test = SD.open("log_test.txt", FILE_WRITE); // ouverture de fichier.txt en mode écriture if (log_test) // Si le fichier a bien était ouvert on ecrit la date et l'heure: { DateTime now = RTC.now(); log_test.print(now.year()); log_test.print('/'); log_test.print(now.month());

Ecriture et lecture dans la Carte SD







log_test.print('/'); log_test.print(now.day()); log_test.print(' '); log_test.print(now.hour()); log_test.print(':'); log_test.print(now.minute()); log_test.print(':'); log_test.print(now.second()); log_test.println(); // fermeture du fichier (Sinon rien ne sera écrit!): log_test.close(); Serial.println("Fini !"); } else { // impossible d'ouvrir/créer le fichier: Serial.println("Erreur d'ouverture de log_test.txt"); } //Deuxieme partie Lecture: log_test=SD.open("log_test.txt"); if(log_test) { Serial.println("log_test.txt:"); // lecture du fichier jusqu'à la fin: while (log_test.available()) { Serial.write(log_test.read()); } // Fermeture du fichier: log_test.close(); } else { // Ouverture impossible: Serial.println("Ouverture impossible de fichier.txt"); } } void loop(void)//le (void) car la fonction loop ne contient rien { }







#include <SD.h> #include <SPI.h> #include <Wire.h> #include <RTClib.h> int capteur_temperature = A11; // Capteur temperature brancher sur le port A11 const int chipSelect = 10; File temperature_resultatFile; RTC_DS1307 RTC; int k=0; // Pour le nombre de resultat pris void setup() { Serial.begin(9600); Wire.begin(); // Debut de la communication I2C RTC.begin(); // Debut de la communication a partir de la librairie RTC RTC.adjust(DateTime(__DATE__, __TIME__));// Reglage de l'horloge grâce au PC Serial.print("Initializing SD card..."); pinMode(51, OUTPUT); if (!SD.begin()) { Serial.println("initialization failed!"); return; } Serial.println("initialization done."); // suprimer le fichier si il existe déjà if (SD.exists("resultat.txt")) { Serial.println("Removing resultat.txt..."); SD.remove("resultat.txt"); } temperature_resultatFile= SD.open("resultat.txt", FILE_WRITE); // ouverture de resultat.txt en écriture } void loop() { while (k<10)//prend que 10 mesures { if (temperature_resultatFile) { Serial.println(k); DateTime now = RTC.now(); // Recherche de la date, heure, grâce a la librairie I2C temperature_resultatFile.print("Le "); temperature_resultatFile.print(now.day()); // Affichage dans le Moniteur série le jour temperature_resultatFile.print('/'); temperature_resultatFile.print(now.month());// Affichage dans le Moniteur série du mois

Ecriture et lecture température dans la Carte SD







temperature_resultatFile.print('/'); temperature_resultatFile.print(now.year()); temperature_resultatFile.print(" à "); temperature_resultatFile.print(now.hour()); temperature_resultatFile.print(':'); temperature_resultatFile.print(now.minute()); temperature_resultatFile.print(':'); temperature_resultatFile.print(now.second()); temperature_resultatFile.print(" "); float temperature = fonction_temperature(); temperature_resultatFile.print("il à fait : "); temperature_resultatFile.print(temperature); temperature_resultatFile.println(" °C"); k=k+1; delay(5000); // prend un mesure toute les 5 secondes } } if (k==10) { // fermeture du fichier et fin du programme: temperature_resultatFile.close(); k=1000; Serial.println("Fini !"); } } float fonction_temperature() { float valeur_capteur_temperature= analogRead(capteur_temperature); // on lit le port "Capteur_temperature" (Port A11) float T1 = (valeur_capteur_temperature/1023)*5; //convertion volt float temperature=(T1-0.4)/0.0195; // convertion degré return temperature; // On renvoit Temperature }



e carte d’extension (« shield l’heure et la date Pour cela ... · Fondé(e) sur une œuvre à...

Documents

Transcript of e carte d’extension (« shield l’heure et la date Pour cela ... · Fondé(e) sur une œuvre à...