IMU: Werte auf SD Karte speichern und wieder öffnen

Hallo zusammen,
ich benutze einen Microcontroller der Marke M5Stack (esp32), mit welchem ich gerne Beschleunigungsdaten aufnehmen möchte (mittels des verbauten IMUs). Ich programmiere in der Arduino IDE, daher wende ich mich auch an dieses Forum.
Zu meinem Problem: Ich nehme mithilfe des M5Stack Beschleunigungsdaten auf, speichere diese auf einer SD Karte (txt Datei) und öffne diese Datei wieder. Diese wieder geöffneten Daten möchte ich gerne integrieren, um damit auf eine Geschwindigkeit zu kommen, lediglich bei eindimensionalen geradlinigen Bewegungen. Für das Speichern und Öffnen nutze ich die vorgefertigten Funktion aus den Beispiel Sketches. Um zu testen, ob ich auf die gespeicherten Daten zugreife um später zu integegrieren habe ich erstmal versucht nur Daten einer Beschleunigunsrichtung (accX) aufzusummieren, leider erfolglos. Ich weiß leider nicht so ganz warum hier eine volllkommen zufällige Zahl für die Variable testX berechnet wird (meine aufgenommen Beschleunigunsgwerte schwanken in Ruhelage so um die 0,01, bei 10 aufgenommen Werten gibt er mir einen aufsummierten Wert von 228 oder höher) . Einfach gesagt, ich möchte Daten aufnehmen, abspeichern, wieder öffnen und mit den gespeicherten Werten weiter arbeiten. Das System soll als ein Fast-Feedback System für Sportler genutzt werden. Diese sollen eine Bewegung durchführen und dann auf dem Display des Sensors eine Geschwindigkeit angezeigt bekommen.

Hier mein Code

#define M5STACK_MPU6886 
#include <M5Stack.h>
#include "FS.h"
#include "SD.h" 
#include "SPI.h"
#include "time.h"
#include "math.h"


float accX = 0.0F;
float accY = 0.0F;
float accZ = 0.0F;
float zeit = 0.0F;
float testX = 0.0F;
char msg[100];
unsigned long zeit_start = 0.0;
unsigned long zeit_end = 0.0;
boolean button_a = false;
boolean measurement = false;
boolean start = true;

void writeFile(fs::FS &fs, const char * path, const char * message){
    Serial.printf("Writing file: %s\n", path);

    File file = fs.open(path, FILE_WRITE);
    if(!file){
        Serial.println("Failed to open file for writing");
        return;
    }
    if(file.print(message)){
        Serial.println("File written");
    } else {
        Serial.println("Write failed");
    }
    file.close();
}

 
void appendFile(fs::FS &fs, const char * path, const char * message){
    Serial.printf("Appending to file: %s\n", path);

    File file = fs.open(path, FILE_APPEND);
    if(!file){
        Serial.println("Failed to open file for appending");
        return;
    }
    if(file.print(message)){
        Serial.println("Message appended");
    } else {
        Serial.println("Append failed");
    }
    file.close();
}


void readFile(fs::FS &fs, const char * path){
    Serial.printf("Reading file: %s\n", path);

    File file = fs.open(path);
    if(!file){
        Serial.println("Failed to open file for reading");
        return;
    }

    Serial.print("Read from file:\n ");
    while(file.available()){
        Serial.write(file.read());

        testX = testX + (abs(accX));
    }
    file.close();
}

void setup() {
 
  M5.begin();
  M5.Power.begin();
  M5.IMU.Init();

  M5.Lcd.println("Press button A to\nstart measurement");

  Serial.begin(115200);
    if(!SD.begin()){
        Serial.println("Card Mount Failed");
        return;
    }
    uint8_t cardType = SD.cardType();

    if(cardType == CARD_NONE){
        Serial.println("No SD card attached");
        return;
    }

    Serial.print("SD Card Type: ");
    if(cardType == CARD_MMC){
        Serial.println("MMC");
    } else if(cardType == CARD_SD){
        Serial.println("SDSC");
    } else if(cardType == CARD_SDHC){
        Serial.println("SDHC");
    } else {
        Serial.println("UNKNOWN");
    }

    uint64_t cardSize = SD.cardSize() / (1024 * 1024);
    Serial.printf("SD Card Size: %lluMB\n", cardSize); 
   
    writeFile(SD, "/acceleration.txt", "   Time    aX       aY        aZ"); 


    while (start){
   
     zeit_start = millis();

     if (M5.BtnA.wasReleasefor(70))
         {
             button_a = (!(button_a));
             measurement = (!(measurement));
          }  

      if (button_a)
      {
        while (measurement)
          { 
              zeit_end = millis()-zeit_start;
              M5.IMU.getAccelData(&accX,&accY,&accZ);
              zeit = (float) zeit_end / 1000.00;

              snprintf(msg, 100, "\r\n  %5.2lf   %5.2lf     %5.2lf     %5.2lf",zeit, accX, accY, accZ); 
              appendFile(SD, "/acceleration.txt", msg);

              if (M5.BtnA.wasReleasefor(70))
                 {
                    button_a = (!(button_a));
                    measurement = (!(measurement));

                    M5.Lcd.println("Press button A to\nstart measurement");

                    readFile(SD, "/acceleration.txt");
                    Serial.println(" ");
                    Serial.println(testX);
                 }
          }

      }
   }
}

Über Hilfe wäre ich dankbar.
Viele Grüße Jan

Und warum muss das eine SD-Karte sein ?
Der ESP32 hat doch mit Spiffs ein eigenes Dateisystem, das du dafür nutzen kannst.

Hallo!
Vielen Dank für die schnelle Rückmeldung und den guten Tipp. Dahingehend habe ich mich tatsächlich bisher nicht informiert und werde dies direkt mal tun. Der Weg über die SD Karte hat sich augenscheinlich angeboten, da somit auch die Möglichkeit bestehen würde in Matlab oder Phyton die aufgenommenen Daten seperat darzustellen und zu analysieren.

Vielen Dank und viele Grüße
Jan

jhenning:
.....Der Weg über die SD Karte hat sich augenscheinlich angeboten, da somit auch die Möglichkeit bestehen würde in Matlab oder Phyton die aufgenommenen Daten seperat darzustellen und zu analysieren.

Auch das geht, wenn die Daten im Spiffs/LittleFS liegen.
Einfach an den externen Rechner übertragen.
Z.B. mit UDP.

Oder per Browser downloaden. Anregungen zum Dateimanager bei Fips.

Gruß Tommy