Go Down

Topic: Enregistrer données GPS sur carte SD (Read 854 times) previous topic - next topic

beyam78

Jul 07, 2018, 09:17 pm Last Edit: Jul 07, 2018, 09:19 pm by beyam78
Bonjour!
J'ai vraiment besoin de vous. D'abord voilà mes outils:
une carte arduino uno
une LoRa GPS Shield with LoRa BEE
un module SD (MicroSD Card Adapter)
Je veux enregistrer les données de la carte GPS dans ma carte SD mais on m'a dit hier que les deux utilisent le même bus SPI donc ne pouvaient cohabiter ensemble. De ce fait j'ai décidé d'opter pour le I2C ,j'ai branché carte GPS sur un arduino UNO et la carte SD sur un autre. J'ai bien testé avec les exemples (slavesender et masterreader) d'arduino pour voir si les branchements sont bons et ça a marché.
Maintenant pour stocker les données c'est autre chose. Voilà mon code pour récupérer les données du GPS dans la carte SD mais je ne sais pas comment le changer puisque je dois utiliser le modèle master-slave.
 
/**
 * Exemple de code Arduino pour un datalogger basique avec stockage sur carte SD.
 */

/* Dépendances */
#include <SPI.h> // Pour la communication SPI
#include <SD.h>  // Pour la communication avec la carte SD
#include <SoftwareSerial.h>
#include <TinyGPS.h>

TinyGPS gps;
SoftwareSerial ss(3, 4); // Arduino TX, RX ,

static void smartdelay(unsigned long ms);
static void print_float(float val, float invalid, int len, int prec);
static void print_int(unsigned long val, unsigned long invalid, int len);
static void print_date(TinyGPS &gps);
static void print_str(const char *str, int len);




/** Broche CS de la carte SD */
const byte SDCARD_CS_PIN = 10; // A remplacer suivant votre shield SD

/** Nom du fichier de sortie */
const char* OUTPUT_FILENAME = "data.csv";

/** Delai entre deux prise de mesures */
const unsigned long DELAY_BETWEEN_MEASURES = 5000;


/** Fichier de sortie avec les mesures */
File file;

/** Fonction setup() */
void setup() {
  ss.begin(9600); // SoftSerial port to get GPS data.
  while (!Serial) {
     ;
  };

  /* Initialisation du port série (debug) */
  Serial.begin(9600);
  /* Initialisation du port SPI */
  pinMode(10, OUTPUT); // Arduino UNO
  //pinMode(53, OUTPUT); // Arduino Mega

  /* Initialisation de la carte SD */
  Serial.println(F("Initialisation de la carte SD ... "));
  if (!SD.begin(SDCARD_CS_PIN)) {
    Serial.println(F("Erreur : Impossible d'initialiser la carte SD"));
    Serial.println(F("Verifiez la carte SD et appuyez sur le bouton RESET"));
    for (;;); // Attend appui sur bouton RESET
  }

  /* Ouvre le fichier de sortie en écriture */
  Serial.println(F("Ouverture du fichier de sortie ... "));
  file = SD.open(OUTPUT_FILENAME, FILE_WRITE);
  if (!file) {
    Serial.println(F("Erreur : Impossible d'ouvrir le fichier de sortie"));
    Serial.println(F("Verifiez la carte SD et appuyez sur le bouton RESET"));
    for (;;); // Attend appui sur bouton RESET
  }
 
  /* Ajoute l'entête CSV si le fichier est vide */
  if (file.size() == 0) {
    Serial.println(F("Ecriture de l'entete CSV ..."));
    file.println(F("Long- Lat- Date et Heure"));
    file.flush();
  }
}


/** Fonction loop() */
void loop() {
  float flat, flon;
  unsigned long age, date, time, chars = 0;
  unsigned short sentences = 0, failed = 0;
  static const double LONDON_LAT = 51.508131, LONDON_LON = -0.128002;

  gps.f_get_position(&flat, &flon, &age);
  print_float(flat, TinyGPS::GPS_INVALID_F_ANGLE, 10, 6);
  print_float(flon, TinyGPS::GPS_INVALID_F_ANGLE, 11, 6);
  print_date(gps);
  gps.stats(&chars, &sentences, &failed);
  Serial.println();
 
  smartdelay(1000);
  //delay(1000);
  // Temps de la précédente mesure et actuel
  static unsigned long previousMillis = 0;
  unsigned long currentMillis = millis();

  /* Réalise une prise de mesure toutes les DELAY_BETWEEN_MEASURES millisecondes */
  if (currentMillis - previousMillis >= DELAY_BETWEEN_MEASURES) {
    previousMillis = currentMillis;
    measure();
  }
}
static void smartdelay(unsigned long ms)
{
  unsigned long start = millis();
  do
  {
    while (ss.available())
    {
      //ss.print(Serial.read());
      gps.encode(ss.read());
    }
  } while (millis() - start < ms);
}

static void print_float(float val, float invalid, int len, int prec)
{
  if (val == invalid)
  {
    while (len-- > 1)
      Serial.print('*');
    Serial.print(' ');
  }
  else
  {
    Serial.print(val, prec);
    int vi = abs((int)val);
    int flen = prec + (val < 0.0 ? 2 : 1); // . and -
    flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
    for (int i=flen; i<len; ++i)
      Serial.print(' ');
  }
  smartdelay(0);
}

static void print_int(unsigned long val, unsigned long invalid, int len)
{
  char sz[32];
  if (val == invalid)
    strcpy(sz, "*******");
  else
    sprintf(sz, "%ld", val);
  sz[len] = 0;
  for (int i=strlen(sz); i<len; ++i)
    sz = ' ';
  if (len > 0)
    sz[len-1] = ' ';
  Serial.print(sz);
  smartdelay(0);
}

static void print_date(TinyGPS &gps)
{
  int year;
  byte month, day, hour, minute, second, hundredths;
  unsigned long age;
  gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths, &age);
  if (age == TinyGPS::GPS_INVALID_AGE)
    Serial.print("********** ******** ");
  else
  {
    char sz[32];
    sprintf(sz, "%02d/%02d/%02d %02d:%02d:%02d ",
        day, month, year, hour, minute, second);
    Serial.print(sz);
  }
  smartdelay(0);
}

static void print_str(const char *str, int len)
{
  int slen = strlen(str);
  for (int i=0; i<len; ++i)
    Serial.print(i<slen ? str : ' ');
  smartdelay(0);
}


/** Fonction de mesure - à personnaliser selon ses besoins */
void measure() {

  /* Réalise la mesure */
  float flon,flat;
  char sz;
  float lon = flon;
  float lat = flat;
  char dateEtHeure = sz;
 
 
  /* Affiche les données sur le port série pour debug */
  Serial.print(lon);
  Serial.print(F("-    "));
  Serial.print(lat);
  Serial.print(F("-    "));
  Serial.println(dateEtHeure);
   
  /* Enregistre les données sur la carte SD */
  file.print(lon);
  file.print(F("- "));
  file.print(F("   "));
  file.print(lat);
  file.print(F("- "));
  file.print(F("   "));
  file.println(dateEtHeure);
  file.flush();
}

Aidez-moi svp c'est urgent.

lesept

Alors, d'abord il faudrait que tu lises les messages épinglés en haut du forum : ils donnent certaines règles qui aident les membres. L'une d'elles est pour le confort de lecture : mettre les codes entre balises CODE (accessibles avec la touche </> lorsque tu écris ton message). Profites-en pour faire un CTRL T dans l'IDE pour l'indenter correctement, ça améliore la lisibilité.

Ca donne ça :
Code: [Select]
mon code iciC'est beaucoup plus facile à lire notamment pour ceux qui lisent sur un smartphone, et pour copier le code dans l'IDE si on veut le tester.

Ensuite, je ne vois pas ce qui empêche tes deux périphériques d'utiliser le même bus SPI, il est même fait pour ça. Exemple, tiré de Wikipedia :



Il peut arriver que les adresses soient codées en dur et qu'elles soient les mêmes pour deux modules, mais ça peut se corriger. Donc reste en SPI et continue comme tu voulais le faire. Si tu rencontres des problèmes avec ton code lors de son fonctionnement, on tentera de t'aider...
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

beyam78

Ah d'accord merci pour l'astuce pour les codes.
En fait quand je branche la carte GPS et le module SD sur la même carte arduino, le module SD refuse de s'initialiser (regarder fichier joint) et sachant que l'initialisation est la première étape avant de pouvoir enregistrer des données, c'est compliqué. Et c'est pourquoi mon prof m'a dit que je dois faire communiquer mes deux cartes par wire I2C


lesept

Je me suis mal exprimé : modifie ton premier message STP.
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

lesept

#4
Jul 08, 2018, 12:36 am Last Edit: Jul 08, 2018, 12:39 am by lesept
Il semble que le Lora GPS Shield communique par liaison série, pas pas bus SPI. C'est pour ça que ton code utilise la bibliothèque SoftwareSerial.
Donc a priori aucun problème de cohabitation sur le bus SPI.

Tu dis "De ce fait j'ai décidé d'opter pour le I2C, j'ai branché la carte GPS sur un arduino UNO et la carte SD sur un autre" : tu utilises 2 Arduinos ? Pour quoi faire ?

Il faut brancher les deux modules sur le même Arduino : son job sera de lire les données du GPS et de les écrire sur la carte. Il faut que tu testes les deux modules séparément avant de faire un programme qui assemble les deux.

Commence par faire un code qui lit les données GPS (un exemple ici) et les met en forme pour les écrire sur la carte.

Ensuite fais un code qui ouvre un fichier et écrit à la fin une donnée (un string par exemple). Avant, comme le module SD semble te poser problème, teste les exemples de la bibliothèque.

Enfin lorsque tout marchera, tu assembleras tes deux programmes, mais ne brûle pas les étapes.

... Au pire tu trouveras des choses toutes faites sur Internet (ici par exemple) mais il vaut mieux faire par toi même :)
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

beyam78

Voilà le code

Code: [Select]
/**
 * Exemple de code Arduino pour un datalogger basique avec stockage sur carte SD.
 */

/* Dépendances */
#include <SPI.h> // Pour la communication SPI
#include <SD.h>  // Pour la communication avec la carte SD
#include <SoftwareSerial.h>
#include <TinyGPS.h>

TinyGPS gps;
SoftwareSerial ss(3, 4); // Arduino TX, RX ,

static void smartdelay(unsigned long ms);
static void print_float(float val, float invalid, int len, int prec);
static void print_int(unsigned long val, unsigned long invalid, int len);
static void print_date(TinyGPS &gps);
static void print_str(const char *str, int len);




/** Broche CS de la carte SD */
const byte SDCARD_CS_PIN = 10; // A remplacer suivant votre shield SD

/** Nom du fichier de sortie */
const char* OUTPUT_FILENAME = "data.csv";

/** Delai entre deux prise de mesures */
const unsigned long DELAY_BETWEEN_MEASURES = 5000;


/** Fichier de sortie avec les mesures */
File file;

/** Fonction setup() */
void setup() {
  ss.begin(9600); // SoftSerial port to get GPS data.
  while (!Serial) {
     ;
  };

  /* Initialisation du port série (debug) */
  Serial.begin(9600);
  /* Initialisation du port SPI */
  pinMode(10, OUTPUT); // Arduino UNO
  //pinMode(53, OUTPUT); // Arduino Mega

  /* Initialisation de la carte SD */
  Serial.println(F("Initialisation de la carte SD ... "));
  if (!SD.begin(SDCARD_CS_PIN)) {
    Serial.println(F("Erreur : Impossible d'initialiser la carte SD"));
    Serial.println(F("Verifiez la carte SD et appuyez sur le bouton RESET"));
    for (;;); // Attend appui sur bouton RESET
  }

  /* Ouvre le fichier de sortie en écriture */
  Serial.println(F("Ouverture du fichier de sortie ... "));
  file = SD.open(OUTPUT_FILENAME, FILE_WRITE);
  if (!file) {
    Serial.println(F("Erreur : Impossible d'ouvrir le fichier de sortie"));
    Serial.println(F("Verifiez la carte SD et appuyez sur le bouton RESET"));
    for (;;); // Attend appui sur bouton RESET
  }
 
  /* Ajoute l'entête CSV si le fichier est vide */
  if (file.size() == 0) {
    Serial.println(F("Ecriture de l'entete CSV ..."));
    file.println(F("Long- Lat- Date et Heure"));
    file.flush();
  }
}


/** Fonction loop() */
void loop() {
  float flat, flon;
  unsigned long age, date, time, chars = 0;
  unsigned short sentences = 0, failed = 0;
  static const double LONDON_LAT = 51.508131, LONDON_LON = -0.128002;

  gps.f_get_position(&flat, &flon, &age);
  print_float(flat, TinyGPS::GPS_INVALID_F_ANGLE, 10, 6);
  print_float(flon, TinyGPS::GPS_INVALID_F_ANGLE, 11, 6);
  print_date(gps);
  gps.stats(&chars, &sentences, &failed);
  Serial.println();
 
  smartdelay(1000);
  //delay(1000);
  // Temps de la précédente mesure et actuel
  static unsigned long previousMillis = 0;
  unsigned long currentMillis = millis();

  /* Réalise une prise de mesure toutes les DELAY_BETWEEN_MEASURES millisecondes */
  if (currentMillis - previousMillis >= DELAY_BETWEEN_MEASURES) {
    previousMillis = currentMillis;
    measure();
  }
}
static void smartdelay(unsigned long ms)
{
  unsigned long start = millis();
  do
  {
    while (ss.available())
    {
      //ss.print(Serial.read());
      gps.encode(ss.read());
    }
  } while (millis() - start < ms);
}

static void print_float(float val, float invalid, int len, int prec)
{
  if (val == invalid)
  {
    while (len-- > 1)
      Serial.print('*');
    Serial.print(' ');
  }
  else
  {
    Serial.print(val, prec);
    int vi = abs((int)val);
    int flen = prec + (val < 0.0 ? 2 : 1); // . and -
    flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
    for (int i=flen; i<len; ++i)
      Serial.print(' ');
  }
  smartdelay(0);
}

static void print_int(unsigned long val, unsigned long invalid, int len)
{
  char sz[32];
  if (val == invalid)
    strcpy(sz, "*******");
  else
    sprintf(sz, "%ld", val);
  sz[len] = 0;
  for (int i=strlen(sz); i<len; ++i)
    sz = ' ';
  if (len > 0)
    sz[len-1] = ' ';
  Serial.print(sz);
  smartdelay(0);
}

static void print_date(TinyGPS &gps)
{
  int year;
  byte month, day, hour, minute, second, hundredths;
  unsigned long age;
  gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths, &age);
  if (age == TinyGPS::GPS_INVALID_AGE)
    Serial.print("********** ******** ");
  else
  {
    char sz[32];
    sprintf(sz, "%02d/%02d/%02d %02d:%02d:%02d ",
        day, month, year, hour, minute, second);
    Serial.print(sz);
  }
  smartdelay(0);
}

static void print_str(const char *str, int len)
{
  int slen = strlen(str);
  for (int i=0; i<len; ++i)
    Serial.print(i<slen ? str : ' ');
  smartdelay(0);
}


/** Fonction de mesure - à personnaliser selon ses besoins */
void measure() {

  /* Réalise la mesure */
  float flon,flat;
  char sz;
  float lon = flon;
  float lat = flat;
  char dateEtHeure = sz;
 
 
  /* Affiche les données sur le port série pour debug */
  Serial.print(lon);
  Serial.print(F("-    "));
  Serial.print(lat);
  Serial.print(F("-    "));
  Serial.println(dateEtHeure);
   
  /* Enregistre les données sur la carte SD */
  file.print(lon);
  file.print(F("- "));
  file.print(F("   "));
  file.print(lat);
  file.print(F("- "));
  file.print(F("   "));
  file.println(dateEtHeure);
  file.flush();
}

beyam78

J'ai bien testé les deux modules. Voilà le code pour tester le module GPS et ça a marché ( le moniteur affiche la latitude, la longitude et la date et l'heure):

Code: [Select]
#include <SoftwareSerial.h>
#include <TinyGPS.h>

TinyGPS gps;
SoftwareSerial ss(3, 4); // Arduino TX, RX ,

static void smartdelay(unsigned long ms);
static void print_float(float val, float invalid, int len, int prec);
static void print_int(unsigned long val, unsigned long invalid, int len);
static void print_date(TinyGPS &gps);
static void print_str(const char *str, int len);

void setup()
{
  // initialize both serial ports:
  Serial.begin(9600);  // Serial to print out GPS info in Arduino IDE
  ss.begin(9600); // SoftSerial port to get GPS data.
  while (!Serial) {
     ;
  };
  Serial.println("            Coordonnées du kit               ");
  Serial.println(" Latitude - Longitude  - Date -   Heure      ");
  Serial.println("   (deg)      (deg)                            ");
  Serial.println("----------------------------------------------");
}

void loop()
{
  float flat, flon;
  unsigned long age, date, time, chars = 0;
  unsigned short sentences = 0, failed = 0;
  static const double LONDON_LAT = 51.508131, LONDON_LON = -0.128002;

  gps.f_get_position(&flat, &flon, &age);
  print_float(flat, TinyGPS::GPS_INVALID_F_ANGLE, 10, 6);
  print_float(flon, TinyGPS::GPS_INVALID_F_ANGLE, 11, 6);
  print_date(gps);
  gps.stats(&chars, &sentences, &failed);
  Serial.println();
 
  smartdelay(1000);
  //delay(1000);
}

static void smartdelay(unsigned long ms)
{
  unsigned long start = millis();
  do
  {
    while (ss.available())
    {
      //ss.print(Serial.read());
      gps.encode(ss.read());
    }
  } while (millis() - start < ms);
}

static void print_float(float val, float invalid, int len, int prec)
{
  if (val == invalid)
  {
    while (len-- > 1)
      Serial.print('*');
    Serial.print(' ');
  }
  else
  {
    Serial.print(val, prec);
    int vi = abs((int)val);
    int flen = prec + (val < 0.0 ? 2 : 1); // . and -
    flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
    for (int i=flen; i<len; ++i)
      Serial.print(' ');
  }
  smartdelay(0);
}

static void print_int(unsigned long val, unsigned long invalid, int len)
{
  char sz[32];
  if (val == invalid)
    strcpy(sz, "*******");
  else
    sprintf(sz, "%ld", val);
  sz[len] = 0;
  for (int i=strlen(sz); i<len; ++i)
    sz[i] = ' ';
  if (len > 0)
    sz[len-1] = ' ';
  Serial.print(sz);
  smartdelay(0);
}

static void print_date(TinyGPS &gps)
{
  int year;
  byte month, day, hour, minute, second, hundredths;
  unsigned long age;
  gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths, &age);
  if (age == TinyGPS::GPS_INVALID_AGE)
    Serial.print("********** ******** ");
  else
  {
    char sz[32];
    sprintf(sz, "%02d/%02d/%02d %02d:%02d:%02d ",
        day, month, year, hour, minute, second);
    Serial.print(sz);
  }
  smartdelay(0);
}

static void print_str(const char *str, int len)
{
  int slen = strlen(str);
  for (int i=0; i<len; ++i)
    Serial.print(i<slen ? str[i] : ' ');
  smartdelay(0);
}


Le module SD marche aussi et c'est le même que j'ai utilisé pour sauvegarder les données de mon détecteur de particules PM 2.5 laser dust sensor. Voilà le code que j'avais écrit pour ça:

Code: [Select]

/**
 * Exemple de code Arduino pour un datalogger basique avec stockage sur carte SD.
 */

/* Dépendances */
#include <SPI.h> // Pour la communication SPI
#include <SD.h>  // Pour la communication avec la carte SD
#include <Arduino.h>
#define LENG 31   //0x42 + 31 bytes equal to 32 bytes
unsigned char buf[LENG];



/** Broche CS de la carte SD */
const byte SDCARD_CS_PIN = 10; // A remplacer suivant votre shield SD

/** Nom du fichier de sortie */
const char* OUTPUT_FILENAME = "data.csv";

/** Delai entre deux prise de mesures */
const unsigned long DELAY_BETWEEN_MEASURES = 5000;


/** Fichier de sortie avec les mesures */
File file;

int PM01Value=0;          //define PM1.0 value of the air detector module
int PM2_5Value=0;         //define PM2.5 value of the air detector module
int PM10Value=0;         //define PM10 value of the air detector module


/** Fonction setup() */
void setup() {

  /* Initialisation du port série (debug) */
  Serial.begin(9600);
  Serial.setTimeout(1500);    //set the Timeout to 1500ms, longer than the data transmission periodic time of the sensor

  /* Initialisation du port SPI */
  pinMode(10, OUTPUT); // Arduino UNO
  //pinMode(53, OUTPUT); // Arduino Mega

  /* Initialisation de la carte SD */
  Serial.println(F("Initialisation de la carte SD ... "));
  if (!SD.begin(SDCARD_CS_PIN)) {
    Serial.println(F("Erreur : Impossible d'initialiser la carte SD"));
    Serial.println(F("Verifiez la carte SD et appuyez sur le bouton RESET"));
    for (;;); // Attend appui sur bouton RESET
  }

  /* Ouvre le fichier de sortie en écriture */
  Serial.println(F("Ouverture du fichier de sortie ... "));
  file = SD.open(OUTPUT_FILENAME, FILE_WRITE);
  if (!file) {
    Serial.println(F("Erreur : Impossible d'ouvrir le fichier de sortie"));
    Serial.println(F("Verifiez la carte SD et appuyez sur le bouton RESET"));
    for (;;); // Attend appui sur bouton RESET
  }
 
  /* Ajoute l'entête CSV si le fichier est vide */
  if (file.size() == 0) {
    Serial.println(F("Ecriture de l'entete CSV ..."));
    file.println(F("PM1.0- PM2.5- PM10"));
    file.flush();
  }
}


/** Fonction loop() */
void loop() {
  // Temps de la précédente mesure et actuel
  static unsigned long previousMillis = 0;
  unsigned long currentMillis = millis();

  /* Réalise une prise de mesure toutes les DELAY_BETWEEN_MEASURES millisecondes */
  if (currentMillis - previousMillis >= DELAY_BETWEEN_MEASURES) {
    previousMillis = currentMillis;
    measure();
  }
 if(Serial.find(0x42)){    //start to read when detect 0x42
    Serial.readBytes(buf,LENG);

    if(buf[0] == 0x4d){
      if(checkValue(buf,LENG)){
        PM01Value=transmitPM01(buf); //count PM1.0 value of the air detector module
        PM2_5Value=transmitPM2_5(buf);//count PM2.5 value of the air detector module
        PM10Value=transmitPM10(buf); //count PM10 value of the air detector module
      }           
    }
  }
 
}

char checkValue(unsigned char *thebuf, char leng)

  char receiveflag=0;
  int receiveSum=0;

  for(int i=0; i<(leng-2); i++){
  receiveSum=receiveSum+thebuf[i];
  }
  receiveSum=receiveSum + 0x42;
 
  if(receiveSum == ((thebuf[leng-2]<<8)+thebuf[leng-1]))  //check the serial data
  {
    receiveSum = 0;
    receiveflag = 1;
  }
  return receiveflag;
}

int transmitPM01(unsigned char *thebuf)
{
  int PM01Val;
  PM01Val=((thebuf[3]<<8) + thebuf[4]); //count PM1.0 value of the air detector module
  return PM01Val;
}

//transmit PM Value to PC
int transmitPM2_5(unsigned char *thebuf)
{
  int PM2_5Val;
  PM2_5Val=((thebuf[5]<<8) + thebuf[6]);//count PM2.5 value of the air detector module
  return PM2_5Val;
  }

//transmit PM Value to PC
int transmitPM10(unsigned char *thebuf)
{
  int PM10Val;
  PM10Val=((thebuf[7]<<8) + thebuf[8]); //count PM10 value of the air detector module 
  return PM10Val;
}


/** Fonction de mesure - à personnaliser selon ses besoins */
void measure() {

  /* Réalise la mesure */
  float PM01 = PM01Value;
  float PM25 = PM2_5Value;
  float PM10 = PM10Value;
 
 
  /* Affiche les données sur le port série pour debug */
  Serial.print(PM01);
  Serial.print(F("-  "));
  Serial.print(PM25);
  Serial.print(F("-  "));
  Serial.println(PM10);
   
  /* Enregistre les données sur la carte SD */
  file.print(PM01);
  file.print(F("- "));
  file.print(PM25);
  file.print(F("- "));
  file.println(PM10);
  file.flush();
}


Les données ont bien été enregistrées dans data.csv dans la carte SD et j'ai visualisé ce qui est écrit sur le fichier avec l'exemple DumpFile.

lesept

Et ton code complet plante lors de l'initialisation de la carte SD?
Essaye de mettre les instructions relatives au GPS après celles relatives à la carte dans le setup.
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

beyam78

J'ai fait ce que vous m'avez conseillée mais j'ai toujours la même erreur

lesept

Si les codes fonctionnent indépendamment, c'est lors de la réunification que se pose le problème, comme on dit à Koh Lanta ! Je pencherais pour un problème d'alimentation : essaye avec une alim plus puissante.

Sinon, es-tu obligé d'utiliser la bibli TinyGPS ? Il semble que TinyGPS++ soit plus simple d'utilisation. Mais il y a peu de chance que changer de bibli règle le problème...
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

beyam78

Bonjour! J'espère que vous allez bien.
J'ai pas bien saisi, comment augmenter l'alimentation?

lesept

Je ne sais pas ce que tu utilises pour alimenter ton montage : le port UsB du PC ? Un chargeur de téléphone ? Si c'est un chargeur, il en existe qui peuvent fournir des courants élevés, jusqu'à 2A ou plus. Le port USB est limité en courant et ne fournit peut-être pas assez pour l'Arduino plus les deux modules.

C'est juste une supposition
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

Go Up