Bonjour à tous,
je travail depuis une semaine sur un système d'acquisition de données constitué de:
- un accéléromètre ADXL345,
- un Arduino UNO-R3,
-un shield µSD SparkFun.
...rien d'extraordinaire donc !
Néanmoins, le but est de faire tourner l'ADXL345 à sa vitesse maximum l'acquisition,
en réccupérant les valeurs brutes d'accélérations X,Y,Z sans traitement,
et de stocker ces valeurs sur une carte µSD à la volé !
... et c'est là que les choses se compliquent ! , en effet
L'ADXL345 est capable de fournir jusqu'à 800 acqs/sec avec son bus I2C cadencé à 400 Khz,
et 3200 acqs/sec avec son bus SPI cadencé à 5 Mhz.
Pour l'instant j'utilise le bus I2C à 400 Khz car je n'ai pas trouvé de librairie SPI pour ADXL345.
Le transfert des données UNO-R3 vers µSD se fait quand à lui par bus SPI.
Pour gérer ce transfert j'utilise la librairie SdFat.h plus performante que la bibrairie SD.h,
elle permet notament de paramètrer la vitesse du bus SPI à sa valeur max, soit 16Mhz/2=8Mhz avec un UNO-R3.
Malgrés ce paramétrage je me heurte à un problème de vitesse d'écrire des données sur la carte µSD.
Il y a deux aspects dans la vitesse d'écriture sur la carte:
1 - la vitesse intrinsèque de la carte en écriture, voir les taux de transfert en classe 10 par exemple,
2 - la vitesse d'éxécution du morceau de code qui gère l'écriture.
Pour l'instant ce qui m'intéresse c'est le point N°2, car j'observe que cette vitesse d'éxécution est très basse,
à tel point que les performances de la librairie SdFat.h semblent incompatible avec mon application !?l
Pour tester cette vitesse j'ai écris le petit code ci-joint.
Pour simplifier les choses l'acquisition de l'accéléromètre est remplacée par des valeurs fixes,
ce qui m'interesse c'est de voir combien de temps met le programme d'écriture des données pour se dérouler,
Pour cela je ne met même pas la carte µSD en place dans son connecteur pour m'affranchir du temps d'écrire (point N°1).
Cela ne pose pas de problème, le maître (UNO-R3) cause sans avoir de retour de l'esclave ( µSD)...
Pour mesurer le temps d'éxécution je place un oscilloscope sur la pin 7 qui me sert de marqueur ( voir le code dans la loop() ).
Dans ces conditions la durée de l'écriture est de 550 µs entre High et Low, ce qui fait grosso modo une fréquence de 1818 hz.
Cette valeur est peut-être acceptable pour faire de l'acquisition à 800 hz, quoi que, il faut voir une fois la carte µSD en place ? mais certainement pas pour fonctionner à 3200 hz !!
J'ai donc tendence à conclure que les librairies disponibles ( SD.h, SdFat.h ...)
ne donnent pas la possibilité d'atteindre des cadences de stockage élevées !?
Cela est peut-être dû à l'utilisation du bus SPI,
pour aller plus vite il faudrait travailler en mode SDIO, mais ça c'est impossible avec UNO !
Quel est votre avis sur cette question ?
Quelqu'un a-t-il des idées pour résoudre ce problème ?
mais peut-être faut-il que je m'oriente vers un autre système ? ...pcduino3 par exemple, cadencé à 1 Ghz !
Voici le code, il est utilisable en l'état, si vous avez le matériel vous pouvez faire l'expérience vous même.
/*
==============================================
le 08 juillet 2014
µC UNO-R3 avec SD Shield SparkFun
===============================================
* Carte SD est connectée au bus SPI de la façon suivante:
** MOSI - pin 11
** MISO - pin 12
** CLK - pin 13
** CS - pin 8
*/
// pour la carte SD
// Sur le SD Shield SparkFun, CS est la pin 8.
const int chipSelect = 8;
#include <SdFat.h>
SdFat sd;
SdFile myFile;
// Valeurs à ecrire dans la carte SD, ax,ay,az sont sur 16 bits, donc deux mots de 8 bits sur le bus SPI
int16_t ax = B10101011; //en binaire pour des raisons de facilité de lecture de la trame SPI à l'oscilloscope
int16_t ay = B10101111;
int16_t az = B10111011;
// La pin 7 sert de marqueur pour visualisation à l'oscilloscope
int MarqPin = 7;
void setup() {
// On met la pin 7 en sortie
pinMode(MarqPin, OUTPUT);
//------------------------------------------------------------------------------------------------
// Initialisation de SdFat
// SPI_FULL_SPEED pour plus de performance,
// le bus SPI est donc à sa cadence maximum, Fosc/2 soit 16Mhz/2 = 8 Mhz.
sd.begin(chipSelect, SPI_FULL_SPEED);
//------------------------------------------------------------------------------------------------
}
void loop() {
digitalWrite(MarqPin, HIGH); // La pin 7 passe à High, débute de cycle d'écriture
// stokage des valeurs sur la carte SD
myFile.open("test.csv", O_RDWR | O_CREAT | O_AT_END); // Ouverture du fichier
myFile.print(ax); // on ecrit ax à l'intérieur du fichier
myFile.print(";"); // on ecrit ; à l'intérieur du fichier
myFile.print(ay); // on ecrit ay à l'intérieur du fichier
myFile.print(";"); // on ecrit ; à l'intérieur du fichier
myFile.println(az); // on ecrit az à l'intérieur du fichier
myFile.close(); // fermeture du fichier
digitalWrite(MarqPin, LOW); // La pin 7 passe à Low, fin de cycle d'écriture
//on recommence indéfiniment pour une nouvelle écriture.
}
Merci pour votre retour,
Cordialement, Thierry.