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