wilhem:
Vielleicht fehlt mir eine irgendwelche Kenntnis...kannst du mir bitte genauer sagen, wie du es meinst???
Also entweder drücke ich mich unklar aus, oder Du hast irgendeine Blockade, es zu verstehen.
Du sollst nicht "alle 1000 male abspeichern", sondern "alle 1000 male die Datei öffnen und schließen", d.h. Du sollst während 1000 Zeilen geschrieben werden die Datei dauernd geöffnet halten!
Anyway, dann hier in Code für Arduino UNO mit SD-Kartenschacht auf einem Ethernet-Shield, vielleicht verstehst Du das in Code ja besser als meine Beschreibung in Textform. Der Code ist angelehnt an das "Datalogger" Programmierbeispiel zur Arduino SD-Library.
/* SD card datalogger
This example shows how to log data from three analog sensors
to an SD card using the SD library.
The circuit:
* analog sensors on analog ins 0, 1, and 2
* SD card attached to SPI bus as follows:
** MOSI - pin 11
** MISO - pin 12
** CLK - pin 13
** CS - pin 4
*/
#include <SD.h>
// 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 = 4;
void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}
Serial.print("Initializing SD card...");
// On the Ethernet Shield, CS is pin 4. It's set as an output by default.
// Note that even if it's not used as the CS pin, the hardware SS pin
// (10 on most Arduino boards, 53 on the Mega) must be left as an output
// or the SD library functions will not work. pinMode(10, OUTPUT); // change this to 53 on a mega
pinMode(10, OUTPUT); // change this to 53 on a mega
// see if the card is present and can be initialized:
if (!SD.begin(chipSelect)){
Serial.println("Card failed, or not present");
while (true==true); // don't do anything more
}
Serial.println("card initialized.");
}
void sensors(File log_file)
// Funktion schreibt eine Logzeile in das bereits geöffnete log_file
{
int x_out = analogRead(A0);
int y_out = analogRead(A1);
int z_out = analogRead(A2);
int p_out = analogRead(A3);
int r_out = analogRead(A4);
int w_out = analogRead(A5);
char data[40];
sprintf(data, "%8lu,%4u,%4u,%4u,%4u,%4u,%4u", millis(), x_out, y_out, z_out, p_out, r_out, w_out);
log_file.println(data);
}
void write1000lines2log(boolean overWriteExistingData)
// Diese Funktion öffnet eine Logdatei zum Schreiben,
// ruft dann 1000 mal eine Funktion auf, die je eine Zeile in die Datei schreibt,
// und schließt die Logdatei danach wieder.
// Mit dem Parameter "overWriteExistingData" kann (im allgemeinen beim ersten Aufruf)
// festgelegt werden, dass eine bereits unter gleichem Namen existierende Datei
// zuerst plattgemacht werden soll, bevor Daten hineingeschrieben werden
{
static long lastRun;
File log_file;
if (overWriteExistingData) // Create new file from scratch, overwrite data if existing
log_file = SD.open("flugXX.txt", O_WRITE | O_CREAT | O_TRUNC);
else
log_file = SD.open("flugXX.txt", O_WRITE);
if (!log_file) Serial.println("error opening flugXX.txt");
else
{
for (int i=0;i<1000;i++)
{
while (millis()-lastRun<4) ;
lastRun=millis();
sensors(log_file);
}
log_file.close();
}
}
boolean FirstRun=true;
void loop()
{
// Mal mindestens 10 Sekunden lang probieren,
// wie oft je 1000 Zeilen ins Log geschrieben werden können
while (millis()<10000)
{
write1000lines2log(FirstRun);
FirstRun=false;
Serial.println("1000 lines - done.");
}
Serial.println(millis());
while (true==true);
}
Die Log-Zeilen sind ein bischen länger als bei Dir, ausgelesen und geloggt werden immer die Werte von den sechs Analog-Pins und zusammen mit dem Stand des millis-Timers, schön in Spalten untereinander stehend.
In Deinem Programm meinte ich zu erkennen, dass eine Zeile alle 4 Millisekunden geschrieben werden soll und so habe ich es nun in den Code geschrieben.
Die Funktion "write1000lines2log" schreibt immer 1000 Zeilen hintereinander weg in die Datei, wobei die Datei nur einmal zu Anfang geöffnet und am Ende geschlossen wird.
Zwischen den 1000er Zeilenblöcken, jedesmal wenn die Datei also geschlossen und wieder geöffnet wird, entsteht eine Verzögerung, so daß zwischen den Zeilen 1000 und 1001 (2000 und 2001, 3000 und 3001 etc.) nicht die üblichen 4 Millisekunden bei der Aufzeichnung liegen wie zwischen den Zeilen innerhalb eines 1000-Zeilen Blocks, sondern eher so um die 15-16 Millisekunden zwischen den Aufzeichnungen an dieser "Trennstelle" in der Logdatei.