projet vélo + GPS + ...

International Français
1

Bonjour à toutes et tous,

Je vous présente ici mon projet de manière assez détaillée afin de ne pas partir sur de fausses pistes car je vais, à coup sûr avoir besoin de votre aide.
Compositeur de musique électroacoustique (utilisateur assez expérimenté de Max/MSP ou Pure Data, beaucoup moins d’Arduino…) , je travaille actuellement à un projet pour le printemps 2015 avec un plasticien qui doit partir pour une résidence longue en Lituanie… à vélo !
Il va donc se fabriquer un vélo « cargo » sur lequel nous souhaiterions installer un certain nombre de capteurs (GPS, fréquence cardiaque, température voire, humidité). L’idée serait de recueillir ces données sous forme de « tableur » (fichier .csv ou .txt, à voir) afin de les utiliser ultérieurement (après « parsing » dans Pure Data ou plutôt dans Max MSP) pour une création sonore et vidéo, travail sur des motifs cartographiques etc
Après d’assez longues recherches sur les systèmes envisageables (Garmin Connect en particulier, Raspberry Pi, LinkIt One), je reviens, une fois de plus, vers Arduino et donc, vers vous !.
Mon idée serait d’utiliser un « stack » composé d’une Uno ou Mega (selon le nombre d’entrées nécessaires), un Ethernet Shield (pour accéder à une carte SD), un shield GPS comme celui-ci (http://www.cooking-hacks.com/gps-module-for-arduino + http://www.cooking-hacks.com/internal-gps-antenna?_bksrc=item2item&_bkloc=product) ainsi qu’un shield type Grove pour les autres capteurs analogiques.

1er problème : si je comprends bien, l’Ethernet Shied (plus exactement, sa carte SD) requiert l’entrée/sortie 4 de la Uno/Mega pour fonctionner or, cette entrée est également utilisée par le shield GPS… Y a t’il un moyen de contourner cela ?

2ème problème : comment réunir toutes les données en un unique tableau ? en utilisant un « array » ? (idéalement, il faudrait que toutes les données apparaissent dans une liste unique dont l’index serait le temps, par exemple, toutes les minutes, afin de simplifier le parsing dans Max).

3ème problème : il faudrait que ce stack soit alimenté par accus (nous souhaitions l’alimenter par l’énergie produite par le vélo mais ça risque d’être compliqué d’avoir une tension constante/régulée…).

4éme problème : le code, car il s’git là du système le plus complexe que j’aie eu à réaliser avec Arduino (jusqu’ici, j’ai surtout utilisé des choses simples, capteur de lumière, de présence ou de pression, solénoïdes etc) mais ça, ça viendra peut-être après…

En résumé, j’aurais souhaité bénéficier de vos lumières afin de savoir si ce projet est réalisable techniquement, avant de me lancer dans quelque chose de trop complexe à mon niveau et d’engager des dépenses inutiles…

Bien à vous et bonnes fêtes,
Nicolas Canot.

2

Hello,

Intéressant comme projet !
Ca semble réalisable mais pour éviter au maximum les embuches il faudrait que tu établisse des spécifications assez précises (poids, taille, comsommation, contraintes liées à l'environnement...)
Quelles sont les fonctions priéordiales et celles qui sont optionnelles...

  1. Pourquoi utiliser un shield Ethernet ? Un Shield Micro SD ne conviendrait-il pas ?
    Faut savoir aussi que les accés à la carte mémoire sont assez gourmands en énergie. L'utilisation d'une EEPROM externe pourrait limiter la conso (mais je pense un peu plus complexe à mettre en oeuvre).

  2. La récupération des données du GPS et l'export en csv se fait sans encombre. Si tu utilise une SD Card tu peux faire 2 fichiers, 1 pour les données GPS et 1 pour les données environnement / santé du pilote :wink:

@+ & Bonne chance.

3

Je continue mes recherches et je me demande si ceci ne serait pas plus adapté : Adafruit Ultimate GPS Logger Shield - Includes GPS Module : ID 1272 : $29.95 : Adafruit Industries, Unique & fun DIY electronics and kits (le shield contient déjà le GPS + carte SD !), sous réserve que je puisse y ajouter 2 ou 3 capteurs analogiques (température + humidité, par exemple) et écrire également les données dans la carte SD ?

4

Aucun problème, tu pourras datalogger tes données sur la SD card avec ce shield.
J'ai utilisé (pour un GPS trakker) la version "éclatée" de ce shield et tout fonctionne.

GPS: GPS Adafruit MORE ULTIMATE v3 - chipset PA1616D
SD Card: Adaptateur Micro SD - version Extra

5

Je regarde la question de l'EEPROM, ça semble assez compliqué vu mon niveau !
Si on utilise le shield Adafruit indiqué dans mon post précédent, peut on envisager de le "brocher" entre la Uno et mon shield type Grove afin de connecter à ce dernier les capteurs analogiques ?

Si j'ai deux fichiers dans la carte SD, il faut qu'ils soient indexés exactement de la même manière (disons, par la même "horloge" que le GPS), est-ce réalisable ?

Pour ce qui est du poids, je pense que ça n'est pas vraiment un problème car le pilote est un adepte du pignon fixe, sur-entrainé (et un peu hipster...). Il n'a jamais que 5000km à parcourir...
Quant bien même l'ensemble atteindrait 1 kg, ça ne poserait pas de problème.
Le cargo sera quelque chose comme ça : pariscargobikes.org - pariscargobikes Resources and Information. et donc, les contraintes seront celles liées à la pratique du vélo sur route (vibrations, pour l'essentiel).
Le périple (qui aura lieu, GPS ou pas !) est prévu à partir de la mi-Mai et retour en Juillet, les températures devraient donc être printanières puis estivales, même au Danemark, sur la Baltique et en Lituanie.

(edit : remarque stupide de ma part, il suffit de fixer l'Adafruit sur le Grove via des headers et ça revient au même...)

6

En fait, concernant les contraintes et fonctions de ton système, je ne m'attendais pas à ce que tu me les liste ici. Ce que je veux dire c'est que tu devrais établir une liste de tout ce qui est succeptible de mettre à mal ton système (pluie, vibrations, vent, sable.... je ne sais pas...) Sers toi du retour d'expérience de gens qui ont déjà fait ce genre de périple peut-être. Avec tout ça tu pourras définir quel type de boitiers tu devras utiliser, comment positionner tes capteurs pour limiter leurs contraintes...
Les gens ont souvent tendance à négliger la phase de préparation / définition mais c'est assez important !
Il est très difficile d'implémenter de nouvelles fonctions dans un soft quand on ne les a pas prévues au départ.
Tu auras de toute façon des imprévus (hardware & Software) donc vaut mieux que tu démarres avec une spécification bien précise de ce que tu veux.

7

Bonjour
projet ambitieux surtout vu du coté fiabilité
sur le papier tu veux donc acquérir et logger

  • loc gps
  • cardio
  • Temperature
  • Hygrometrie

sur le papier avec :

  • 1 petit arduino
  • 1 module GPS,
  • 1 module SD
  • 1 capteur de temperature
  • 1 capteur hygro
  • 1 capteur cardio (peut etre le le choix le plus compliqué à faire)

il n'y a AMHA pas vraiment besoin d'une grosse récurrence de log
faire un log des acquisitions toutes les 5 secondes doit etre amplement suffisant

8

Voila où j'en suis de mon "panier d'achat virtuel"...
À priori, pas besoin de shield type Grove puisque, si je comprends bien, les capteurs pourraient être connectés/soudés directement aux entrées analogiques de la Uno via la "grille centrale" du shield GPS puis raccordés aux capteurs via des connecteurs adaptés.

shield GPS + carte SD : https://www.adafruit.com/products/1272

antenne externe + adaptateur : https://www.adafruit.com/products/960 + https://www.adafruit.com/products/851

capteur cardio : Pulse Sensor Amped : ID 1093 : $25.00 : Adafruit Industries, Unique & fun DIY electronics and kits

capteur de température : Waterproof 1-Wire DS18B20 Digital temperature sensor : ID 381 : $9.95 : Adafruit Industries, Unique & fun DIY electronics and kits

batteries : Lithium Ion Polymer Battery - 3.7v 2500mAh : ID 328 : $14.95 : Adafruit Industries, Unique & fun DIY electronics and kits + USB LiIon/LiPoly charger [v1.2] : ID 259 : $12.50 : Adafruit Industries, Unique & fun DIY electronics and kits

  • un peu de câble et Arduino R3, bien entendu.

Ça vous semble à peu près cohérent ?

9

ton capteur cardio, il est mis au doigt, alors c'est pas pratique de garder ca en faisant du velo, ca coute pas chers, mais pourquoi pas partir sur une ceinture cardio ou de ce style et avoir a longueur de journée?
Heart Rate Educational Starter Pack with Polar Wireless Sensors : ID 1077 : $65.00 : Adafruit Industries, Unique & fun DIY electronics and kits plus chers, mais plus pratique

sur ton shield GPS, tu as deja l'antenne GPS, donc a toi de voir, si tu veux une antenne externe filaire qui sera seulement utile si ton systeme est dans une boite fermé

10

Je n'avais pas vu celui là !
(l'autre capteur peut aussi être porté à l'oreille)
À voir avec le "pédaleur" et... le budget de prod...

merci !

11

pour la question de l'antenne externe : le "stack" sera protégé, à l'abris dans un boitier étanche et isolé des vibrations donc, l'antenne interne ne fonctionnera probablement pas correctement non ?

12

nakatano:
Voila où j'en suis de mon "panier d'achat virtuel"...
À priori, pas besoin de shield type Grove puisque, si je comprends bien, les capteurs pourraient être connectés/soudés directement aux entrées analogiques de la Uno via la "grille centrale" du shield GPS puis raccordés aux capteurs via des connecteurs adaptés.

shield GPS + carte SD : https://www.adafruit.com/products/1272

antenne externe + adaptateur : https://www.adafruit.com/products/960 + https://www.adafruit.com/products/851

capteur cardio : Pulse Sensor Amped : ID 1093 : Adafruit Industries, Unique & fun DIY electronics and kits

capteur de température : Waterproof 1-Wire DS18B20 Digital temperature sensor : ID 381 : Adafruit Industries, Unique & fun DIY electronics and kits

batteries : Lithium Ion Polymer Battery - 3.7v 2500mAh : ID 328 : Adafruit Industries, Unique & fun DIY electronics and kits + USB LiIon/LiPoly charger [v1.2] : ID 259 : Adafruit Industries, Unique & fun DIY electronics and kits

  • un peu de câble…

Ça vous semble à peu près cohérent ?

AMHA je ne pense pas que le capteur cardio (IR sur doigt ) soit approprié à ton (son) projet
perso je verrais plus un cardio thoracique HF

Je ne pense pas non plus que partir sur du shield (empilable) soit une bonne solution
un module GPS externe est AMHA preferable
un module SD externe aussi
le capteur de temp , ok un ds18b20 tubé inox
il te manque le capteur hygro (regarde vers DHT22)

Jean-François avait fait une realisation pour son vélo couché , il y a surement des bonnes bases d'inspiration ,
mais pour l'instant je ne retrouve pas le topic

13

ok pour l'antenne filaire,
enfin avoir un capteur a l'oreille, mise a part l'air idiot c'est pas pratique, avec les secousses ect.. donc un capteur thoracique sera plus approprié

14

Je lis vos remarque et regarde les solutions que vous me proposez et ce point, j'aurais quelques questions* à vous poser :

Pourquoi me conseillez vous des modules séparés plutôt qu'un stack (qui, spontanément, me parait une solution aisée à mettre en œuvre, mais je me trompe sans doute) ?

Les systèmes Adafruit Flora (https://learn.adafruit.com/category/flora) semblent assez "sexy" (ils pourraient être intégrés à la combinaison) mais je ne pense pas qu'ils aient suffisamment d'entrées pour y connecter, par exemple, un GPS + un accéléromètre + un module SD ?

  • à ce stade, GMTW (le plasticien) et moi en sommes au stade de recherche de la meilleure solution/compromis faisabilité/portabilité/interêt des données collectées selon les types de capteurs. Pourquoi pas un accéléromètre/gyroscope, par exemple qui est assez intéressant en création sonore (par exemple, cette pièce a été improvisée avec un patch Max et les accéléromètres de 2 Wiimotes : https://soundcloud.com/nakatano/ten-seconds-teardrops-one-sample-one-bar-one-pitch-series).
15

nakatano:
Je lis vos remarque et regarde les solutions que vous me proposez et ce point, j'aurais quelques questions* à vous poser :

Pourquoi me conseillez vous des modules séparés plutôt qu'un stack (qui, spontanément, me parait une solution aisée à mettre en œuvre, mais je me trompe sans doute) ?

bonjour
attention ça c'est mon avis perso à moi que j'ai :grin:
shield implique à l'origine la recherche du ou des capteurs/dispositifs pour le monter sur une base enfichable,
le principe est simple et utile , mais cette simplicité implique aussi des contraintes (.
dans un projet comme le tien (le votre) , il est à mon sens preferable dejà sourcer les bons/meilleurs/adequats capteurs
pour les positionner là où c'est le mieux, et les adapter simplement sur l'arduino.

pour etre tres franc , pour ce qui est du gps/cardio je partirais (pour la connaitre) sur une base keymaze 700 (le nom a peut etre changé aujourd'hui)
ça fait du log gps+cardio , c'est etanche, facile à utiliser
et j'utiliserais un arduino avec rtc pour enregistrer d'autres parametres , le principal etant au final d'avoir un horodatage "commun"

16

Bonjour à tous

Je « déterre » donc ce post (qui n’avait rien d’enterré), ayant avancé sur la question. Nous avons donc choisi la solution parties séparées, Adafruit Flora + GPS + accéléromètre/compas + RTC + carte microSD*. Nous déciderons ensuite si nous ajoutons d’autres capteurs ou non, en fonction du budget et de la faisabilité technique.

J’ai câblé/soudé les différentes parties et les ai testées individuellement (je veux dire par là, en chargeant uniquement le code nécessaire au fonctionnement de chacune des parties). Tout fonctionne parfaitement. J’ai également légèrement modifié le code du GPS et de l’accéléromètre afin de n’afficher que les data dont j’ai réellement besoin et faciliter ainsi le « parsing » dans Max. Là encore, tout est ok, y compris dans Max.

Il est donc temps, maintenant, de commencer à assembler le code complet et c’est là que débutent mes soucis car je ne sais pas par où commencer ni comment organiser tout cela…

J’essaye d’abord de réunir les données du GPS + Accel en une seule liste et, bien entendu, mon code ne fonctionne pas (plus exactement, il compile mais rien ne s’affiche, ni dans le moniteur de l’IDE, ni dans Max…)…
S’agirait-il d’un problème de « synchro » entre la « vitesse de lecture » du GPS et de l’Accel ?

Il semblerait également que je risque d’avoir un soucis de SRAM disponible… S’il le faut, nous switcherons vers une carte Arduino Mega, moins « sexy » au regard du projet mais bon, l’essentiel est que ça fonctionne, au bout du compte…

Merci de votre aide,
Nicolas.

// Test code for Adafruit Flora GPS modules
//
// This code shows how to listen to the GPS module in an interrupt
// which allows the program to have more 'freedom' - just parse
// when a new NMEA sentence is available! Then access data when
// desired.
//
// Tested and works great with the Adafruit Flora GPS module
// ------> http://adafruit.com/products/1059
// Pick one up today at the Adafruit electronics shop
// and help support open source hardware & software! -ada
     
#include <Adafruit_GPS.h>
#include <SoftwareSerial.h>
#include <Wire.h>
#include <Adafruit_LSM303.h>

Adafruit_GPS GPS(&Serial1);
Adafruit_LSM303 lsm;

     
// Set GPSECHO to 'false' to turn off echoing the GPS data to the Serial console
// Set to 'true' if you want to debug and listen to the raw GPS sentences
#define GPSECHO false
     
// this keeps track of whether we're using the interrupt
// off by default!
boolean usingInterrupt = false;
     
void setup()
{
  // connect at 115200 so we can read the GPS fast enough and echo without dropping chars
  // also spit it out
  Serial.begin(115200);
  Serial.println(F("Adafruit GPS library basic test!"));
     
  // 9600 NMEA is the default baud rate for Adafruit MTK GPS's- some use 4800
  GPS.begin(9600);
  // uncomment this line to turn on RMC (recommended minimum) and GGA (fix data) including altitude
  GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA);
  // uncomment this line to turn on only the "minimum recommended" data
  //GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCONLY);
  // For parsing data, we don't suggest using anything but either RMC only or RMC+GGA since
  // the parser doesn't care about other sentences at this time
  // Set the update rate
  GPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ); // 1 Hz update rate
  // For the parsing code to work nicely and have time to sort thru the data, and
  // print it out we don't suggest using anything higher than 1 Hz
     
  // Request updates on antenna status, comment out to keep quiet
  GPS.sendCommand(PGCMD_ANTENNA);

  delay(1000);
  // Ask for firmware version
  Serial1.println(F(PMTK_Q_RELEASE));
  
  // initialize the LSM303 ?
 
  if (!lsm.begin())
  
    Serial.println(F("Oops ... unable to initialize the LSM303. Check your wiring!"));
    while (1);
  
}
     
     
     
uint32_t timer = millis();
void loop() // run over and over again
{
  
  // read data from the GPS in the 'main loop'
  char c = GPS.read();
  // if you want to debug, this is a good time to do it!
  if (GPSECHO)
    if (c) Serial.print(c);
  // if a sentence is received, we can check the checksum, parse it...
  if (GPS.newNMEAreceived()) {
    // a tricky thing here is if we print the NMEA sentence, or data
    // we end up not listening and catching other sentences!
    // so be very wary if using OUTPUT_ALLDATA and trytng to print out data
    Serial.println(GPS.lastNMEA()); // this also sets the newNMEAreceived() flag to false
    if (!GPS.parse(GPS.lastNMEA())) // this also sets the newNMEAreceived() flag to false
      return; // we can fail to parse a sentence in which case we should just wait for another
  }
  // if millis() or timer wraps around, we'll just reset it
  if (timer > millis()) timer = millis();
     
  // approximately every 2 seconds or so, print out the current stats
  if (millis() - timer > 2000) {
    timer = millis(); // reset the timer
    Serial.print(F("\nTime: "));
    Serial.print(GPS.hour, DEC); Serial.print(':');
    Serial.print(GPS.minute, DEC); Serial.print(':');
    Serial.print(GPS.seconds, DEC); Serial.print('.');
    Serial.println(GPS.milliseconds);
    Serial.print(F("Date: "));
    Serial.print(GPS.day, DEC); Serial.print('/'); {
    Serial.print(GPS.month, DEC); Serial.print("/20");
    Serial.println(GPS.year, DEC);
    Serial.print(F("Fix: ")); Serial.print((int)GPS.fix);
    Serial.print(F(" quality: ")); Serial.println((int)GPS.fixquality);
    if (GPS.fix) {
      Serial.print(F("Location: "));
      Serial.print(GPS.latitude, 4); Serial.print(GPS.lat);
      Serial.print(F(", "));
      Serial.print(GPS.longitude, 4); Serial.println(GPS.lon);
      Serial.print(F("Speed (knots): ")); Serial.println(GPS.speed);
      Serial.print(F("Angle: ")); Serial.println(GPS.angle);
      Serial.print(F("Altitude: ")); Serial.println(GPS.altitude);
      Serial.print(F("Satellites: ")); Serial.println((int)GPS.satellites);
      
  lsm.read();
   Serial.print((int)lsm.accelData.x); Serial.print(F(" "));
   Serial.print((int)lsm.accelData.y); Serial.print(F(" "));
   Serial.print((int)lsm.accelData.z); Serial.print(F(" "));
   Serial.print((int)lsm.magData.x);   Serial.print(F(" "));
   Serial.print((int)lsm.magData.y);   Serial.print(F(" "));
   Serial.print((int)lsm.magData.z); Serial.println(F(" "));
    }
  }
}
}
17

J'ai donc réussi (...) à faire fonctionner cette partie du code (il manquait simplement deux {} …).
Le voici

// Test code for Adafruit Flora GPS modules
//
// This code shows how to listen to the GPS module in an interrupt
// which allows the program to have more 'freedom' - just parse
// when a new NMEA sentence is available! Then access data when
// desired.
//
// Tested and works great with the Adafruit Flora GPS module
// ------> http://adafruit.com/products/1059
// Pick one up today at the Adafruit electronics shop
// and help support open source hardware & software! -ada
     
#include <Adafruit_GPS.h>
#include <SoftwareSerial.h>  
#include <Wire.h>
#include <Adafruit_LSM303.h>
#include <SD.h>
#include <Time.h>
#include <SPI.h>

Adafruit_GPS GPS(&Serial1);
Adafruit_LSM303 lsm;

     
// Set GPSECHO to 'false' to turn off echoing the GPS data to the Serial console
// Set to 'true' if you want to debug and listen to the raw GPS sentences
#define GPSECHO false

// this keeps track of whether we're using the interrupt
// off by default!
boolean usingInterrupt = false;

void setup()
{
  // connect at 115200 so we can read the GPS fast enough and echo without dropping chars
  // also spit it out
  while (!Serial);     // wait for Serial monitor to connect
  Serial.begin(115200);
  Serial.println(F("Adafruit GPS library basic test!"));
  
     
  // 9600 NMEA is the default baud rate for Adafruit MTK GPS's- some use 4800
  GPS.begin(9600);
  // uncomment this line to turn on RMC (recommended minimum) and GGA (fix data) including altitude
  GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA);
  // uncomment this line to turn on only the "minimum recommended" data
  //GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCONLY);
  // For parsing data, we don't suggest using anything but either RMC only or RMC+GGA since
  // the parser doesn't care about other sentences at this time
  // Set the update rate
  GPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ); // 1 Hz update rate
  // For the parsing code to work nicely and have time to sort thru the data, and
  // print it out we don't suggest using anything higher than 1 Hz
     
  // Request updates on antenna status, comment out to keep quiet
  GPS.sendCommand(PGCMD_ANTENNA);

  delay(1000);
  // Ask for firmware version
  Serial1.println(F(PMTK_Q_RELEASE));
  
  // initialize the LSM303 ?
  if (!lsm.begin())
  {
   Serial.println(F("Oops ... unable to initialize the LSM303. Check your wiring!"));
   while (1);
  }
  
}
     
uint32_t timer = millis();
void loop() // run over and over again
{
  
  // read data from the GPS in the 'main loop'
  char c = GPS.read();
  // if you want to debug, this is a good time to do it!
  if (GPSECHO)
    if (c) Serial.print(c);
  // if a sentence is received, we can check the checksum, parse it...
  if (GPS.newNMEAreceived()) {
    // a tricky thing here is if we print the NMEA sentence, or data
    // we end up not listening and catching other sentences!
    // so be very wary if using OUTPUT_ALLDATA and trytng to print out data
    // Serial.println(GPS.lastNMEA()); // this also sets the newNMEAreceived() flag to false :j'ai changé cette ligne qui doit
    // imprimer les données brutes du GPS
    if (!GPS.parse(GPS.lastNMEA())) // this also sets the newNMEAreceived() flag to false
      return; // we can fail to parse a sentence in which case we should just wait for another
  }
  // if millis() or timer wraps around, we'll just reset it
  if (timer > millis()) timer = millis();
     
  // approximately every 2 seconds or so, print out the current stats
  if (millis() - timer > 2000) {
    timer = millis(); // reset the timer
  
    Serial.print(GPS.hour, DEC); Serial.print(' ');
    Serial.print(GPS.minute, DEC); Serial.print(' ');
    Serial.print(GPS.seconds, DEC); Serial.print(' ');
    Serial.print(GPS.milliseconds);
    Serial.print(" ");
    Serial.print(GPS.day, DEC); Serial.print(' '); {
    Serial.print(GPS.month, DEC); Serial.print(F(" "));
    Serial.print(GPS.year, DEC);
    Serial.print(F(" ")); Serial.print((int)GPS.fix);
    Serial.print(F(" ")); Serial.print((int)GPS.fixquality); Serial.print(F(" "));
  if (GPS.fix) {
  
    Serial.print(GPS.latitude, 4); Serial.print(GPS.lat); Serial.print(F(" "));
    Serial.print(GPS.longitude, 4); Serial.print(GPS.lon); Serial.print(F(" "));
    Serial.print(GPS.speed); Serial.print(F(" "));
    Serial.print(GPS.angle); Serial.print(F( " "));
    Serial.print(GPS.altitude); Serial.print(F(" ")); // le chiffre suivant est le nombre de sattellites connectés
    Serial.print((int)GPS.satellites); Serial.print(F(" "));
      
  lsm.read();
   Serial.print((int)lsm.accelData.x); Serial.print(F(" "));
   Serial.print((int)lsm.accelData.y); Serial.print(F(" "));
   Serial.print((int)lsm.accelData.z); Serial.print(F(" "));
   Serial.print((int)lsm.magData.x);   Serial.print(F(" "));
   Serial.print((int)lsm.magData.y);   Serial.print(F(" "));
   Serial.print((int)lsm.magData.z); Serial.println(F(" "));
    }
  }
}
}

J'obtiens donc désormais dans le moniteur (et d'ailleurs, dans Max) une ligne comme celle)ci qui contient toutes les infos dont j'ai besoin pour le moment (celles du GPS + accel):

17 33 8 984 30 1 15 1 2 4915.5551N 402.0839E 0.33 226.16 99.80 6 -332 504 780 361 -384 -468

Il faudrait donc que je réussisse à l'écrire dans un fichier de la carte SD (soudée et testée, tout fonctionne), ligne par ligne (String ?) en les "indexant" de manière à pouvoir les lire ensuite depuis cette même carte et je ne sais pas trop par où commencer...

18

J'imagine qu'il faut commencer par "déclarer" la carte SD, ce que j'essaye de faire ici, en obtenant le message d'erreur suivant : error: expected initializer before 'char'

// Test code for Adafruit Flora GPS modules
//
// This code shows how to listen to the GPS module in an interrupt
// which allows the program to have more 'freedom' - just parse
// when a new NMEA sentence is available! Then access data when
// desired.
//
// Tested and works great with the Adafruit Flora GPS module
// ------> http://adafruit.com/products/1059
// Pick one up today at the Adafruit electronics shop
// and help support open source hardware & software! -ada
     
#include <Adafruit_GPS.h>
#include <SoftwareSerial.h>  
#include <Wire.h>
#include <Adafruit_LSM303.h>
#include <SD.h>
#include <Time.h>
#include <SPI.h>

Adafruit_GPS GPS(&Serial1);
Adafruit_LSM303 lsm;

// On the Ethernet Shield, CS is pin 4. Note that even if it's not
// used as the CS pin, the hardware CS pin (10 on most Arduino boards,
// 53 on the Mega) must be left as an output or the SD library
// functions will not work.
const int chipSelect = 10; //déclaration de l'entrée pour la carte SD

File dataFile; // nom du fichier carte SD ?
char c;

     
// Set GPSECHO to 'false' to turn off echoing the GPS data to the Serial console
// Set to 'true' if you want to debug and listen to the raw GPS sentences
#define GPSECHO false

// this keeps track of whether we're using the interrupt
// off by default!
boolean usingInterrupt = false;

void setup()

{
  // connect at 115200 so we can read the GPS fast enough and echo without dropping chars
  // also spit it out
  while (!Serial);     // wait for Serial monitor to connect
  Serial.begin(115200);
  Serial.println(F("Adafruit GPS library basic test!"));
  
     
  // 9600 NMEA is the default baud rate for Adafruit MTK GPS's- some use 4800
  GPS.begin(9600);
  // uncomment this line to turn on RMC (recommended minimum) and GGA (fix data) including altitude
  GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA);
  // uncomment this line to turn on only the "minimum recommended" data
  //GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCONLY);
  // For parsing data, we don't suggest using anything but either RMC only or RMC+GGA since
  // the parser doesn't care about other sentences at this time
  // Set the update rate
  GPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ); // 1 Hz update rate
  // For the parsing code to work nicely and have time to sort thru the data, and
  // print it out we don't suggest using anything higher than 1 Hz
     
  // Request updates on antenna status, comment out to keep quiet
  GPS.sendCommand(PGCMD_ANTENNA);

  delay(1000);
  // Ask for firmware version
  Serial1.println(F(PMTK_Q_RELEASE));
  
  // initialize the LSM303 ?
  if (!lsm.begin())
  {
   Serial.println(F("Oops ... unable to initialize the LSM303. Check your wiring!"));
   while (1);
  }
  
  //================================================
  {
    // initialisation de la carte SD
  Serial.print(F("Initializing SD card..."));
  // make sure that the default chip select pin is set to
  // output, even if you don't use it:
  pinMode(SS, OUTPUT);
  
  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println(F("Card failed, or not present"));
    // don't do anything more:
    while (1) ;
  }
  Serial.println(F("card initialized."));
  
  // Open up the file we're going to log to!
  dataFile = SD.open("datalog.txt", FILE_WRITE);
  if (! dataFile) {
    Serial.println(F("error opening datalog.txt"));
    // Wait forever since we cant write data
    while (1) ;
  }
  // fin init carte SD
  
}

//============================================
     
uint32_t timer = millis();
void loop() // run over and over again
  
  // read data from the GPS in the 'main loop'
  char c = GPS.read();
  // if you want to debug, this is a good time to do it!
  if (GPSECHO)
    if (c) Serial.print(c);
  // if a sentence is received, we can check the checksum, parse it...
  if (GPS.newNMEAreceived()) {
    // a tricky thing here is if we print the NMEA sentence, or data
    // we end up not listening and catching other sentences!
    // so be very wary if using OUTPUT_ALLDATA and trytng to print out data
    // Serial.println(GPS.lastNMEA()); // this also sets the newNMEAreceived() flag to false :j'ai changé cette ligne qui doit
    // imprimer les données brutes du GPS
    if (!GPS.parse(GPS.lastNMEA())) // this also sets the newNMEAreceived() flag to false
      return; // we can fail to parse a sentence in which case we should just wait for another
  }
  // if millis() or timer wraps around, we'll just reset it
  if (timer > millis()) timer = millis();
     
  // approximately every 2 seconds or so, print out the current stats
  if (millis() - timer > 2000) {
    timer = millis(); // reset the timer
  
    Serial.print(GPS.hour, DEC); Serial.print(' ');
    Serial.print(GPS.minute, DEC); Serial.print(' ');
    Serial.print(GPS.seconds, DEC); Serial.print(' ');
    Serial.print(GPS.milliseconds);
    Serial.print(" ");
    Serial.print(GPS.day, DEC); Serial.print(' '); {
    Serial.print(GPS.month, DEC); Serial.print(F(" "));
    Serial.print(GPS.year, DEC);
    Serial.print(F(" ")); Serial.print((int)GPS.fix);
    Serial.print(F(" ")); Serial.print((int)GPS.fixquality); Serial.print(F(" "));
  if (GPS.fix) {
  
    Serial.print(GPS.latitude, 4); Serial.print(GPS.lat); Serial.print(F(" "));
    Serial.print(GPS.longitude, 4); Serial.print(GPS.lon); Serial.print(F(" "));
    Serial.print(GPS.speed); Serial.print(F(" "));
    Serial.print(GPS.angle); Serial.print(F( " "));
    Serial.print(GPS.altitude); Serial.print(F(" ")); // le chiffre suivant est le nombre de sattellites connectés
    Serial.print((int)GPS.satellites); Serial.print(F(" "));
      
  lsm.read();
   Serial.print((int)lsm.accelData.x); Serial.print(F(" "));
   Serial.print((int)lsm.accelData.y); Serial.print(F(" "));
   Serial.print((int)lsm.accelData.z); Serial.print(F(" "));
   Serial.print((int)lsm.magData.x);   Serial.print(F(" "));
   Serial.print((int)lsm.magData.y);   Serial.print(F(" "));
   Serial.print((int)lsm.magData.z); Serial.println(F(" "));
    }
  }
}

puis écrire dans un fichier la liste qu'affichent les séries de Serial.print...

Quelqu'un de charitable pour venir à mon aide ?

19

Ooops, nouveau problème, le code semble compiler mais est trop gros pour la carte FLora...
Je vais donc devoir basculer vers une Mega !?

Sinon, le code...

// Test code for Adafruit Flora GPS modules
//
// This code shows how to listen to the GPS module in an interrupt
// which allows the program to have more 'freedom' - just parse
// when a new NMEA sentence is available! Then access data when
// desired.
//
// Tested and works great with the Adafruit Flora GPS module
// ------> http://adafruit.com/products/1059
// Pick one up today at the Adafruit electronics shop
// and help support open source hardware & software! -ada
     
#include <Adafruit_GPS.h>
#include <SoftwareSerial.h>  
#include <Wire.h>
#include <Adafruit_LSM303.h>
#include <SD.h>
#include <Time.h>
#include <SPI.h>

Adafruit_GPS GPS(&Serial1);
Adafruit_LSM303 lsm;
char c = (' ');

// On the Ethernet Shield, CS is pin 4. Note that even if it's not
// used as the CS pin, the hardware CS pin (10 on most Arduino boards,
// 53 on the Mega) must be left as an output or the SD library
// functions will not work.
const int chipSelect = 10; //déclaration de l'entrée (sortie ?) pour la carte SD

File dataFile; // nom du fichier carte SD ?


     
// Set GPSECHO to 'false' to turn off echoing the GPS data to the Serial console
// Set to 'true' if you want to debug and listen to the raw GPS sentences
#define GPSECHO false

// this keeps track of whether we're using the interrupt
// off by default!
boolean usingInterrupt = false;

void setup()

{
  // connect at 115200 so we can read the GPS fast enough and echo without dropping chars
  // also spit it out
  while (!Serial);     // wait for Serial monitor to connect
  Serial.begin(115200);
  Serial.println(F("Adafruit GPS library basic test!"));
  
     
  // 9600 NMEA is the default baud rate for Adafruit MTK GPS's- some use 4800
  GPS.begin(9600);
  // uncomment this line to turn on RMC (recommended minimum) and GGA (fix data) including altitude
  GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA);
  // uncomment this line to turn on only the "minimum recommended" data
  //GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCONLY);
  // For parsing data, we don't suggest using anything but either RMC only or RMC+GGA since
  // the parser doesn't care about other sentences at this time
  // Set the update rate
  GPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ); // 1 Hz update rate
  // For the parsing code to work nicely and have time to sort thru the data, and
  // print it out we don't suggest using anything higher than 1 Hz
     
  // Request updates on antenna status, comment out to keep quiet
  GPS.sendCommand(PGCMD_ANTENNA);

  delay(1000);
  // Ask for firmware version
  Serial1.println(F(PMTK_Q_RELEASE));
  
  // initialize the LSM303 ?
  if (!lsm.begin())
  {
   Serial.println(F("Oops ... unable to initialize the LSM303. Check your wiring!"));
   while (1);
  }
  
  //================================================
  {
    // initialisation de la carte SD
  Serial.print(F("Initializing SD card..."));
  // make sure that the default chip select pin is set to
  // output, even if you don't use it:
  pinMode(SS, OUTPUT);
  
  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println(F("Card failed, or not present"));
    // don't do anything more:
    while (1) ;
  }
  Serial.println(F("card initialized."));
  
  // Open up the file we're going to log to!
  dataFile = SD.open("datalog.txt", FILE_WRITE);
  if (! dataFile) {
    Serial.println(F("error opening datalog.txt"));
    // Wait forever since we cant write data
    while (1) ;
  }
  // fin init carte SD
  
}
}

//============================================
     
uint32_t timer = millis();
void loop() // run over and over again
{

  // read data from the GPS in the 'main loop'
  char c = GPS.read();
  // if you want to debug, this is a good time to do it!
  if (GPSECHO)
    if (c) Serial.print(c);
  // if a sentence is received, we can check the checksum, parse it...
  if (GPS.newNMEAreceived()) {
    // a tricky thing here is if we print the NMEA sentence, or data
    // we end up not listening and catching other sentences!
    // so be very wary if using OUTPUT_ALLDATA and trytng to print out data
    // Serial.println(GPS.lastNMEA()); // this also sets the newNMEAreceived() flag to false :j'ai changé cette ligne qui doit
    // imprimer les données brutes du GPS
    if (!GPS.parse(GPS.lastNMEA())) // this also sets the newNMEAreceived() flag to false
      return; // we can fail to parse a sentence in which case we should just wait for another
  
  }
  // if millis() or timer wraps around, we'll just reset it
  if (timer > millis()) timer = millis();
     
  // approximately every 2 seconds or so, print out the current stats
  if (millis() - timer > 2000) {
    timer = millis(); // reset the timer
      Serial.print(GPS.hour, DEC); Serial.print(' ');
    Serial.print(GPS.minute, DEC); Serial.print(' ');
    Serial.print(GPS.seconds, DEC); Serial.print(' ');
    Serial.print(GPS.milliseconds);
    Serial.print(" ");
    Serial.print(GPS.day, DEC); Serial.print(' '); {
    Serial.print(GPS.month, DEC); Serial.print(F(" "));
    Serial.print(GPS.year, DEC);
    Serial.print(F(" ")); Serial.print((int)GPS.fix);
    Serial.print(F(" ")); Serial.print((int)GPS.fixquality); Serial.print(F(" "));
  if (GPS.fix) {
  
    Serial.print(GPS.latitude, 4); Serial.print(GPS.lat); Serial.print(F(" "));
    Serial.print(GPS.longitude, 4); Serial.print(GPS.lon); Serial.print(F(" "));
    Serial.print(GPS.speed); Serial.print(F(" "));
    Serial.print(GPS.angle); Serial.print(F( " "));
    Serial.print(GPS.altitude); Serial.print(F(" ")); // le chiffre suivant est le nombre de sattellites connectés
    Serial.print((int)GPS.satellites); Serial.print(F(" "));
      
  lsm.read();
   Serial.print((int)lsm.accelData.x); Serial.print(F(" "));
   Serial.print((int)lsm.accelData.y); Serial.print(F(" "));
   Serial.print((int)lsm.accelData.z); Serial.print(F(" "));
   Serial.print((int)lsm.magData.x);   Serial.print(F(" "));
   Serial.print((int)lsm.magData.y);   Serial.print(F(" "));
   Serial.print((int)lsm.magData.z); Serial.println(F(" "));
  
  
    }
  }
  }
  }
20

Bonjour,

Quelque nouvelles de ce projet qui a bien avancé.
Le système GPS + accel + compas écrit désormais, en autonomie, dans la carte. Une LED indique la bonne détection (ou non) des satellites. Je dois encore calibrer les accel et compas pour en déduire l'orientation instantanée.
La récupération et filtrage des données dans Max ne pose aucun problème.

Un premier test "in situ" va donc être réalisé à partir de demain entre Reims et Lille et retour.

Le RTC Chronodot qui m'a été conseillé fonctionne (disons qu'il écrit ses données dans la carte) mais je ne comprends pas comment l'utiliser en réalité : doit-il remplacer le "timer" (millis ?) de la Mega et comment ?

Connaitriez vous un bon tutoriel sur ce sujet (RTC + GPS) ?

J'ai également des soucis avec le capteur de température TMP102 mais cela fait l'objet d'un autre post sur ce forum.

Restera ensuite à "cleaner" quelque peu le câblage...

Bien à vous.

P1040075.JPG
P1040075.JPG1500×1125 737 KB