mon ARDUINO Uno avec interface SD card

Bonsoir

Oui je peux maintenant écrire et lire des fichiers dans une SD card à partir du ARDUINO
Je peux aussi les lire sur le P C

Les branchements sont faits ainsi :
gnd
3.3V
cs digital 10
mosi digital 11
sck digital 13
miso digital 12

CS ou ChipSelect pour activer la communication
MISO (Master Input, Slave Output) broche de transmission équivalent à la borne Tx d’un port série. Sortie du module.
MOSI (Master Output, Slave Input) broche de réception équivalent à la borne Rx d’un port série. Entrée du module.
SCK (Clock) horloge permettant de synchroniser la communication

Un soucis, ma card de 16Gb (16Go) n'a que 2.7Gb de déclarés, bien que avec FAT32

www.aranacorp.com/fr/lire-et-ecrire-sur-une-carte-sd-avec-arduino/

gnd, 3.3V
cs digital 10 (ici 10 au lieu 4)
mosi digital 11
sck digital 13
miso digital 12

Le module de carte SD présente 6 broches pour permettre d’établir la connexion.
2 connexions pour l’alimentation et 4 pour établir la liaison SPI (Serial Peripheral Interface)

5V ou 3.3V pour l’alimentation du module
GND la masse du module
CS ou ChipSelect pour activer la communication
MISO (Master Input, Slave Output) broche de transmission équivalent à la borne Tx d’un port série. Sortie du module.
MOSI (Master Output, Slave Input) broche de réception équivalent à la borne Rx d’un port série. Entrée du module.
SCK (Clock) horloge permettant de synchroniser la communication

3.3V sur 3.3V
GND sur GND
CS généralement sur 4 (ici sur 10)
MISO sur 12
MOSI sur 11
SCK sur 13


programme  infos carte S D

SPI.h
SD.h

Sd2Card card;
SdVolume volume;
SdFile root;

const int chipSelect = 10;

int resultat;

void setup()
{
 Serial.begin(9600);
 while (!Serial) {
  }
 


 Serial.print("\nInitializing SD card...");

resultat = card.init(SPI_HALF_SPEED, chipSelect);
 if (!resultat)
{
   Serial.print("initialization failed  ");
   Serial.println(resultat);
   return;
  }
 else {
    Serial.print("Wiring is correct and a card is present.  ");
    Serial.println(resultat);
  }

 Serial.print("\nCard type: ");
 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("Unknown");
  }

 if (!volume.init(card))
{
   Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
   return;
  }

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

 volumesize = volume.blocksPerCluster();    clusters are collections of blocks
 volumesize *= volume.clusterCount();       we'll have a lot of clusters
 volumesize *= 512;                            SD card blocks are always 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);
}


void loop(void) {}



Initializing SD card...Wiring is correct and a card is present.

Card type: SDHC

Volume type is FAT32

Volume size (bytes): 2936012800
Volume size (Kbytes): 2867200
Volume size (Mbytes): 2800

Files found on the card (name, date and size in bytes):
SYSTEM~1/     2021-08-26 17:11:00
 INDEXE~1      2021-08-26 17:11:00 76
 WPSETT~1.DAT  2021-08-26 17:11:00 12




programme lire ecrire carte S D

SPI.h
SD.h

File myFile;

String buffer;
String filename = "test";

int resultat;

void setup()
{
 Serial.begin(9600);
 while (!Serial) {
  }


 Serial.print("Initializing SD card...");

resultat = SD.begin(10); 4 devient 10
 if (!resultat)
{
   Serial.print("initialization failed!  ");
   Serial.println(resultat);
   return;
  }
 Serial.print("initialization done.  ");
 Serial.println(resultat);


 myFile = SD.open(filename + ".txt", FILE_WRITE);

 if (myFile)
{
   Serial.print("Writing to " + filename + ".txt...");
   myFile.println("testing 1, 2, 3.");
   myFile.close();
   Serial.println("done.");
  }
 else
{
   Serial.println("error opening " + filename + ".txt");
  }
 Read file byte by byte
 myFile = SD.open(filename + ".txt");
 if (myFile)
{
   Serial.println("Read " + filename + ".txt byte by byte:");

while (myFile.available())
{
      Serial.write(myFile.read());
    }

    myFile.close();
  }
 else {

    Serial.println("error opening " + filename + ".txt");
  }

 Read file line by line
 myFile = SD.open(filename + ".txt");
 if (myFile)
{
   Serial.println("Read " + filename + ".txt line by line:");

    while (myFile.available())
{
      buffer = myFile.readStringUntil('\n');
      Serial.println(buffer);
    }
  myFile.close();
  }
 else
{
   Serial.println("error opening " + filename + ".txt");
  }

}

void loop() { }



Il est possible d’effacer le fichier en utilisant la fonction:

SD.remove("test.txt");

Attention: Si vos fichiers ne sont pas reconnus, essayez d’utiliser un nom court pour le fichier enregistré sur la carte SD (max 8 caractères).
En effet, le nombre de caractères pour un fichier sur une carte SD est limité avec Arduino.*



programme afficher contenu de fichiers

Libraries
SD.h www.arduino.cc/en/reference/SD
SPI.h www.arduino.cc/en/Reference/SPI

Constants
define SD_ChipSelectPin 10    4 devient 10

Objects
File root;

int resultat;

void printFilenames(void ) { function printFilenames
 find files in SD card
 root = SD.open("/");
 while (true) {
   File entry =  root.openNextFile();
   if (! entry) {
     break;// no more files
   }
   Serial.println(entry.name());
   entry.close();
 }
 root.close();

}

void setup()
{
 Init Serial USB
 Serial.begin(9600);
 Serial.println(F("Initialize System"));
 Init sd shield
resultat = SD.begin(SD_ChipSelectPin);
 if (!resultat)
{
    Serial.print(F("SD fail  "));
    Serial.println(resultat);
    return;
  }
 Serial.print("SD ok  ");
 Serial.println(resultat);
 printFilenames();

}

void loop() {

}

c'est la methode que j'ai employé pour mon premier module GPS. C'est super simple à utiliser. Cependant les cartes SD ont une facheuse tendance à sortir de leur lecteur et de plus il faut des cartes SD de bonne qualité sinon elles sont trop lente.
Si la vitesse d'ecriture est importante il est préférable d'utiliser une eeprom

Tout à fait, il y a l'EEPROM de l'ARDUINO
Je peux mesurer ce timing (oscilloscope et ON OFF pin précise)
Sinon il faudra (je ferais) placer ce support SD en perpendiculaire par rapport à l'accélération
En clair, à plat et non debout dans la fusée (qui est elle même posée à la verticale)
Il ne faut pas manquer ces enregistrements

Bonjour

Hier j'ai fait des manips pour la société, qui comprennent
acquisitions numériques (100 par seconde) et enregistrement fichier dans S D card
(au passage S D est Secure Digital, regarder https://fr.wikipedia.org/wiki/Carte_SD)

J'arrive à faire (à partir de R T C Real Time Clock) des noms de fichier avec D + date + hour + minute
J'ai pu déterminer avec :

readRTC();
for (index=0; index<1000000; index++)
{
sensorValue0 = analogRead(sensorPin0);
myFile.println(sensorValue0);
}
readRTC();

que
1'52" = 112" pour 1000000 fois analogRead
5'53" = 353" pour 1000000 fois analogRead + myFile.println
et
112µs par acquisition analogique
241µs par écriture dans le fichier sur S D card

ça veux dire que tu arrive à ecrire quoi ? juste un float 100 fois par seconde?
J'avais remarqué que ça dépendait du type de carte SD, c'est un peu comme lorsque tu mets une carte SD dans une caméra, si elle n'est pas suffisement rapide rien n'arrive à etre ecris.
Si je te dis ça c'est que mes premiers tests avec le GPS ecrivaient sur une carte SD et j'étais limité par la vitesse d'ecriture de la carte

Salut

Déjà c'est une VERBATIM 16Go
Non 100 par seconde, c'était moi qui avait limité volontairement ( par delay(9) )
Ce qui a donné 3000 mesures pour 30secs (mise en route d'onduleurs et examen V & I des accus)

Il faudra que je détermine le temps de lecture
Là 241µs par float, cela donne environ 4000 par seconde
De toutes façons, je pense limiter à quatre par seconde, les enregistrements de ma floppée de mesures
Je ferais des mesures et peut être que je passerais à huit par seconde

Oui pour 25 images par seconde, il est sûr que c'est différent ET il faut des éléments qui suivent la cadence

Le timing je le mesure à l'oscilloscope en activant désactivant une sortie (led pin13 ou une autre, pin9 par exemple)
Oui je mesure pour connaître le rythme de la 'musique'
J'eu un jour entendu "on ne peut pas aller plus vite que la musique"

En fait ce n'est pas 'float' mais 'int' (en décimal)

Voilà un résumé des timings :

bmp180
bool success0 = bmp180.begin();   6 ms
status = bmp180.startTemperature();   320 µs
status = bmp180.getTemperature(T);    620 µs
status = bmp180.startPressure(3);   320 µs
status = bmp180.getPressure(P, T);   840 µs
alt = bmp180.altitude(P, Po);        0 ?
seaLevelPressure = bmp180.sealevel(P, alt);    0 ?

mpu6050
    sensors_event_t a, g, temp;
    mpu.getEvent(&a, &g, &temp); les deux ensembles 3.5 ms

dht11
  DHT11.read(DHT11PIN); 22 ms

pcf8591
Wire.requestFrom(PCF8591, 5); 0.8 ms

adcvalue0=Wire.read();
adcvalue0=Wire.read();
adcvalue1=Wire.read();
adcvalue2=Wire.read();
adcvalue3=Wire.read(); les cinq ensembles  12 µs

ds3231
  Year = Clock.getYear();
  Month = Clock.getMonth(Century);
  Date = Clock.getDate(); les trois ensembles 1.4 ms

  Hour = Clock.getHour(h12, PM);    24-hr
  Minute = Clock.getMinute();
  Second = Clock.getSecond(); les trois ensembles 1.4 ms


ARDUINO
112µs par acquisition analogique
void loop() { }     1 µs  
digitalWrite(sorPin, LOW);      4 µs

S D interface
241µs par écriture (d'une variable INT en décimal) dans un fichier

ce qui donnerait environ 40ms à chaque tour de mes acquisitions


Un résumé des variables :
bmp180 un double
pcf8591 quatre bytes
mpu6050 sept valeurs
dht11 deux float
ds3231 six bytes
donc un total de vingt à écrire à chaque tour de mes acquisitions
ce qui donnerait environ 5ms

Après il faut laisser de la marge pour que ça s'ecrive bien. Sinon pendant que l'ecriture se fait tu peux en profiter pour faire d'autres operations du moment que cela n'utilise pas le meme bus

Bien dit mais notre ARDUINO n'a pas d'interface intelligente indépendante pour écrire/lire sur S D card
C'est son processeur dans le ATmega qui fait ce travail,
et on ne peut pas lui demander autre chose durant ce temps

lem75pat a écrit:Bien dit mais notre ARDUINO n'a pas d'interface intelligente indépendante pour écrire/lire sur S D card
C'est son processeur dans le ATmega qui fait ce travail,
et on ne peut pas lui demander autre chose durant ce temps

Si c'est possible au lieu de faire des fonctions delay pour attendre la fin de l'ecriture tu verifies le temps ecoulé à chaque boucle ce qui te permet de faire d'autres instructions pendant ce temps. Regardes "state machine" sur internet

Oui tout à fait, concernant la fonction delay() je ne dis pas, mais c'est bien la seule que l'on peut utiliser ainsi

Sinon bonjour à tous

Sur mon ARDUINO Uno et avec une 'horloge à trotteuse' j'ai pu mesurer le temps d'exécution pour ces boucles

for (index=0; index<100000; index++) 100000  150000 200000
{
  sensorValue0 = analogRead(sensorPin0);
myFile.println(sensorValue0);
}

while (myFile.available())
{
resultat = myFile.read();
index++;
    }

    while (myFile.available())
{
      buffer = myFile.readStringUntil('\n');
index++;
    }

Ce afin de déterminer le temps d'exécution de ces instructions :

  sensorValue0 = analogRead(sensorPin0);
myFile.println(sensorValue0);
resultat = myFile.read();
      buffer = myFile.readStringUntil('\n');

Je suis arrivé à ces valeurs unitaires :

  analogRead(sensorPin0); 115µs
myFile.println(sensorValue0); 200µs
myFile.read(); 44µs
      myFile.readStringUntil('\n'); 345µs

En repensant au sujet 'Télémétrie qui parle', je pourrais faire avec
i'm free by the soup dragons
J'y reviendrais