Catégories
Arduino capteur Carte SD Projets Arduino

Projet Data logger avec Arduino: Récupération et exploitation des données

Objectifs du projet

    1. Savoir exploiter les données de la carte mémoire
    2. Savoir générer un script Matlab automatique pour la lecture du fichier
    3. Savoir récupérer les données des fichiers textes
    4. Savoir  mettre en forme les données et les affichées
    5. Etc.

Parties précédentes

Je vous recommande de consulter les parties précédentes du projet ci-dessous pour en savoir plus sur les détails du projet !

Récupération des données

Dans cette partie on va utiliser la logiciel matlab pour la lecture et affichage des données d’un fichier texte. On va utiliser un outil matlab pour la génération automatique du script (voir la vidéo). Ensuite, il suffit de spécifie le nom et l’extension du fichier ainsi le délimiteur. La fonction retourne un tableau 2D des données. Caque ligne contient les échantillons ainsi la date et l’heure. Ci-dessous un exemple du contenu du fichier.

Contenu du fichier texte

Le programme Matlab

Importation des données

NomFich='C:\SD\F510550.TXT';
delim=',';
D0 = GetData( NomFich, delim);
Data=D0/1e3;

Conversion Tab 2D => 1D (sans date & heure)

Data1=Data(:,1:end-6);
Data2=Data1';
Data_1D=Data2(:);

Affichage des données

subplot(121); plot(Data_1D(:),'linewidth',2); grid on;
xlabel('Temps(s)'); ylabel('Résistance(KR)');
title(strcat('Mesures à > ',num2str(D0(end,end-3)),':',num2str(D0(end,end-4))));

subplot(122); plot(Data1,'linewidth',2); grid on;
xlabel('Temps(s)'); ylabel('Résistance(KR)');
title(strcat('Mesures à > ',num2str(D0(end,end-3)),':',num2str(D0(end,end-4))));

Programme complet

clear all; close all; clc



% Importation des données
NomFich='C:\SD\F510550.TXT';
delim=',';
D0 = GetData( NomFich, delim);
Data=D0/1e3;


% Conversion Tab 2D => 1D (sans date & heure)
Data1=Data(:,1:end-6);
Data2=Data1';
Data_1D=Data2(:);

% Affichage des données
subplot(121); plot(Data_1D(:),'linewidth',2); grid on;
xlabel('Temps(s)'); ylabel('Résistance(KR)');
title(strcat('Mesures à > ',num2str(D0(end,end-3)),':',num2str(D0(end,end-4))));

subplot(122); plot(Data1,'linewidth',2); grid on;
xlabel('Temps(s)'); ylabel('Résistance(KR)');
title(strcat('Mesures à > ',num2str(D0(end,end-3)),':',num2str(D0(end,end-4))));

Affichage des données

Affichage de la résistace

Programme Arduino (version à jour du code)


/*
* Projet Data logger: Récupération des données 4/4
* wwww.Electronique-Mixte.fr
* Vesrion: 5_2_2021
*/


#include <Wire.h>
#include "RTClib.h"
#include <SPI.h>
#include <SD.h>
#define CS 10
#define V 5.00
#define R 10000.0
#define PinINT4 2 // PE4 - PIN 2
#define WriteLEDPin 7
#define N 6
#define TFile 60 // 1 Fichier /Minute


RTC_DS1307 rtc;
word DateHeure[6]={0,0,0,0,0,0};
double R_l=0.0, Data[N];


Sd2Card card;
SdVolume volume;
SdFile root;

File myFile;
String StrDATA="";
String NomFichier="F0000.txt"; // Fichier Initial (A ne pas tenir en compte)
bool LEDEtat=false;


void setup()
{
// Init INT4
InitInt4(PinINT4);

// Init LED Ecriture (changement d'état pour chaque écriture dans le fichier)
pinMode(WriteLEDPin, OUTPUT);
digitalWrite(WriteLEDPin,LEDEtat);

// Initialisation du port série: Affichage locale des données
Serial.begin(9600);

// Initialisation du Module RTC (Heure de l'ordinateur)
InitRTC();

// Initialisation de la carte SD
InitSD(CS);

// Stockage des données dans le fichier (Fichier par défaut)
//WriteSD(Data, DateHeure, N, NomFichier);

// Réouverture et Affichage du contenu du fichier (Fichier par défaut)
//ReadDisFile(NomFichier);

}




void loop()
{
//Lecture de l'horloge
GetDateHeure(DateHeure);
}


ISR(INT4_vect) //ISR(_VECTOR(5))
{
// Compteur des échantillons
static long count=0;

// Désactivation de l'interruption globale
cli();

// Lecture du capteur de luminosité
R_l= GetData(A0);

// Mise à jour du buffer des échantillons
Data[count]=R_l;

// Mise à jour du compteur
count++; count=count%N;

// Mise à jour du nom du fichier
NomFichier= UpdateNomFile(TFile, DateHeure, NomFichier);

// Stockage des données dans la carte Mémoire
if(!count) //count=N: stockage lorsque le buffer est plein
{
// Stockage des données dans la carte SD
WriteSD(Data, DateHeure, N, NomFichier);

// Réouverture et Affichage du contenu du fichier (Pour la vérification)
//Serial.println(NomFichier);//////////////////////
//ReadDisFile(NomFichier);

// LED d'état
LEDEtat=!LEDEtat;
digitalWrite(WriteLEDPin,LEDEtat);
}

// Réactivation de l'interruption globale
sei();
}

void ReadDisFile(String NomFich)
{
// 1. Réouverture du fichier
myFile = SD.open(NomFich);

if (myFile)
{
// 2. Lecture & Affichage du contenu du fichier
while (myFile.available()) {
Serial.write(myFile.read());
}

// 3. Fermeture du fichier
myFile.close();
} else
{
Serial.println("Erreur d'ouverture du fichier "+ NomFich);
}
Serial.println("\n\n");
}

String UpdateNomFile(unsigned long TempsFile, word *Horloge, String OldName)
{
String NewNom="";
unsigned long T;
T=Horloge[0]+60*Horloge[1]+3600*Horloge[2]; // HH:MM:SS


if(!(T%TempsFile)) // Changement du nom du fichier toutes les TempsFile
{
for(int i=3;i>=0;i--)
{
NewNom=NewNom+String(Horloge[i]);
}
NewNom="F"+NewNom+".txt";
}
else
NewNom=OldName;

return NewNom;
}



void WriteSD(double *DataIn, word *Horloge, int Taille, String NomFich)
{
String StrDATA="";

// 1. Ouverture du fichier en écriture
File myFile = SD.open(NomFich, FILE_WRITE);

// 2-3. Conversion et Stockage des données dans la carte mémoire
if (myFile)
{
// Données
for(int i=0;i<Taille; i++)
{
// 2. Conversion des données en chaine de caractaire
StrDATA=String(DataIn[i])+",";

// 3. Stockage dans la carte SD
myFile.print(StrDATA);
}

// Date & Heure
for(int i=0;i<6; i++)
{
// 2. Conversion des données en chaîne de caractère
StrDATA=String(Horloge[i])+",";

// 3. Stockage dans la carte SD
myFile.print(StrDATA);
}

myFile.print("\n"); // Retour à la ligne

// 4. Fermeture du fichier
myFile.close();
}
else
{
Serial.println("Erreur d'ouverture du fichier "+NomFichier);
}
}




void GetDateHeure(word *DateHeure)
{
// Lecture du module RTC
DateTime now = rtc.now();

// Récupération de la date
DateHeure[5]=now.year(); // Années
DateHeure[4]=now.month(); // Mois
DateHeure[3]=now.day(); // Jours

// Récupération de l'heure
DateHeure[2]=now.hour();
DateHeure[1]=now.minute();
DateHeure[0]=now.second();
}

void InitRTC(void)
{
if (! rtc.begin())
{
Serial.println("Le module RTC non disponible");
while (1); // Attente RESET
}
else
{
Serial.println("Le module RTC est OK");
rtc.writeSqwPinMode(DS1307_SquareWave1HZ);
//DS1307_SquareWave1HZ = 0x10, // 1Hz square wave
//DS1307_SquareWave4kHz = 0x11, // 4kHz square wave
//DS1307_SquareWave8kHz = 0x12, // 8kHz square wave
//DS1307_SquareWave32kHz = 0x13 // 32kHz square wave
rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // Date du PC

//rtc.adjust(DateTime(2020,1,24,10,10,10)); // Ajustement manuel
// Ex: 10 Janvier 2020 à 10:00:00:
// rtc.adjust(DateTime(2020, 1, 10, 10, 0, 0));
}
}


void InitInt4(byte PinINT)
{
// Entrée de synchronisation 1PPS / INT4
pinMode(PinINT, INPUT);

// Activation de l'interruption globale (registre SREG)
SREG|=0x80;

// Validation de l'interruption INT4 (Registre EIMSK)
EIMSK|=0x10; // INT4

// Choix du mode de détection: Front montant dans INT4
EICRB|=0x03;
}


void InitSD(byte ShipSel)
{
// Positionner à "1" le CS: Activation du module
pinMode(ShipSel, OUTPUT);
digitalWrite(ShipSel, HIGH);

// Initialisation
Serial.print("\n Initialisation de la carte SD...");

if (!card.init(SPI_HALF_SPEED, CS)) {
Serial.println("Initialisation échouée");
//return;
} else {
Serial.println("Le câblage est OK et la carte est disponible.");
}

Serial.print("\nType de la carte: ");
switch (card.type()) {
case SD_CARD_TYPE_SD1:
Serial.println("SD1");
break;
case SD_CARD_TYPE_SD2:
Serial.println("SD2");
break;
case SD_CARD_TYPE_SDHC:
Serial.println("SDHC");
break;
default:
Serial.println("Non reconnue!");
}

if (!volume.init(card)) {
Serial.println("La partition FAT16/FAT32 non dispo.\n Assurez-vous bien de bien formater la carte");
return;
}

uint32_t volumesize;
Serial.print("\nVolume type is FAT");
Serial.println(volume.fatType(), DEC);
Serial.println();

volumesize = volume.blocksPerCluster(); // clusters = somme des blocks
volumesize *= volume.clusterCount();
volumesize *= 512; // les blocs ont souvent la taille de 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);

root.ls(LS_R | LS_DATE | LS_SIZE);

if (!SD.begin(CS)) {
Serial.println("Initialisation échouée!");
while (1);
}
Serial.println("Initialisation réussie.");
}

double GetData(byte Analog_pin)
{
word A0_val;
double V0, R_ll;

// Lecture du capteur
A0_val=analogRead(Analog_pin);

// Conversion en volt [0,1023]=>[0, 5V]
V0=(double)A0_val*V/1023.00;

// Calcul de la résistance en Ohm
R_ll=((V/V0)-1.0)*R;

// Renvoie de la valeur
return R_ll;
}

Tout les projets Arduino

 

Laisser un commentaire