ESP2866 - SPIFFS .txt letzte Zeile lesen

[Ron (Gast)]

Hallo liebe Community,

ich versuche einen Außen-Temperatursensor mit einem EP2866 und der 
Arduino IDE zu programmieren. Im groben läuft es wie folgt ab.
      -  Temperatur Messen und Werte im 2D Array Speichern
      -  2D Array in eine .txt Datei auf dem Flash Speichern
      -  .txt Datei mittels FTP an Fritzbox senden
Soweit funktioniert das. Probleme habe ich jedoch beim auslesen der .txt 
Datei.
In der .txt steht folgender Inhalt:
    #;1;22:38:44;01;01.10;ESP2866;Fahrradschuppen;
Ich möchte gerne die am Anfang stehende laufende Nummer der letzten 
Zeile auslesen( von der .txt im flash)
Ich dachte dass ich das über die Funktion Stream.find() machen kann. 
(über .find() die Anzahl Zeilen bestimmen und dann zur letzten Zeile 
Springen) Allerdings erhalte ich immer ein false.

Einen Ansatz mit fester Zeilenbreite habe ich noch nicht verfolgt. Würde 
es gerne so versuchen.

Ich hoffe es kann mir jemand einen Denkanstoß geben wie ich eine .txt im 
Flash an bestimmten Stellen lesen kann.

Mein Beipielcode:

#include "FS.h"

void setup() {
  Serial.begin(9600); 
  delay(1000);
  
  SPIFFS.begin();
  File f = SPIFFS.open( "/FTP-Daten/test.txt", "r"); // Datei zum lesen öffnen
  if (!f) {
    Serial.println("file open failed");
  }
  String data = f.readString();                      // Inhalt der Textdatei wird gelesen...
  Serial.println("Inhalt der geöffneten Datei:");
  Serial.println(data);                              // ... und wieder ausgegeben


  f.seek(0,SeekSet);                                 // verschiebt den Cursor vom anfang
  
  char  Such        = 35;                            // 35 = #
  float Groesse     = f.size();                      // größe der Datei in bytes wird ausgelesen
  float Position    = f.position();                  // Aktuelle Position des Cursors in Byte

  int Anzahl        = 0;
  bool Gefunden     = 0;
  do{
      Serial.print("Schleifennr.");
      Serial.println(Anzahl);
      Gefunden = f.find(Such);
      Anzahl++;
  }while (Gefunden = false);

   Serial.println(Anzahl);
   Serial.println(Such);
   Serial.println(Gefunden);

  Serial.println(Groesse);
  Serial.println(Position);
 
  f.close();
}
void loop() {

  delay(1000);
}

[Matthias L. (lindner8712)]

Hi,
wie wäre es denn mit:

String data="";
    while(file.available()) { 
        data= file.readStringUntil('\n');
    }

somit hast schonmal die letzte Zeile in einer Variablen.
Nur noch zerlegen:

NummerMax=split(data,';',2);2ten teil des Strings lesen
 
String split(String s, char parser, int index) {
  String rs="";
  int parserIndex = index;
  int parserCnt=0;
  int rFromIndex=0, rToIndex=-1;
  while (index >= parserCnt) {
    rFromIndex = rToIndex+1;
    rToIndex = s.indexOf(parser,rFromIndex);
    if (index == parserCnt) {
      if (rToIndex == 0 || rToIndex == -1) return "";
      return s.substring(rFromIndex,rToIndex);
    } else parserCnt++;
  }
  return rs;
}

Die Methode ansich ist aber ziemlich unschön.
je mehr Daten du wegspeicherst desto länger dauert die Suche weil 
jedesmal
die gesamte Datei durchgenudelt werden muss...
Evtl die letzte Nummer in einer Datei oder EEPROM zu speichern
und die dann bei Bedarf auslesen?


Gruß

[Ron (Gast)]

Guten Abend,
vielen Dank für die schnelle Antwort und den Beispielcode 💐. Ich habe 
die letzten Abende damit verbracht die Logik dahinter zu verstehen und 
auf dieser Basis selber diese Funktion zu programmieren.
Soweit klappt alles.

Dass diese Methode unschön ist habe ich schon häufig gelesen. Ich konnte 
es aber noch nicht nachvollziehen warum (Blockierungsfreie 
Programmierung). In meinen Fall ist die Datei nach 3 Monaten 426Kb groß. 
Wird die Datei komplett durchsucht dauert das etwa 20s. Nun Springe ich 
mit

f.seek(100,SeekEnd);

bis kurz vor das Ende. Somit dauert die Suche nur noch 1s. Das sollte 
doch keine Probleme machen.

Die letzte Nummer im EEPROM zu Speichern wäre wohl die einfachste 
Variante gewesen das Problem zu lösen. Diese Methode kannte ich aber 
schon und ich wollte etwas Neues ausprobieren.

Vielen Dank nochmal und für Interessierte hier meine Variante um aus 
einer im Flash liegenden .txt Datei, Daten aus der letzten Zeile 
wiederzugeben.

MFG: Ron

#include "FS.h"

void setup() {
  Serial.begin(9600); 
  delay(1000);

  String Spalte2 = _WertAusLetzteZeile (2,';');    // (Spalte,Trennzeichen) 
  Serial.print("Wert aus Spalte 2: ");
  Serial.println(Spalte2);
}
void loop() {

  delay(1000);
}

String _WertAusLetzteZeile (int Spalte, char Trennzeichen){

  SPIFFS.begin();
  File f = SPIFFS.open( "/FTP-Daten/test_30Tage.txt", "r");                   // Datei zum lesen öffnen
  if (!f) {
    Serial.println("file open failed");
  }
//String data = f.readString();                                               // Inhalt der gesamten Textdatei wird gelesen...
//Serial.println("Inhalt der geöffneten Datei:");
//Serial.println(data);                                                       // ... und wieder ausgegeben
  Serial.println();

// **** Letzte Zeile aus der im SPIFFS abgelegten .txt Datei suchen ***********************************************************

                // es wird bis kurz vor das ende gesprungen damit das suchen der Letztn Zeile nicht so lange dauert
  if (f.size() > 200){                                          // wenn die Datei größer 200byte ist wird gesprungen
//   f.seek(100,SeekSet);                                       // SeekSet -> Position wird auf "offset" Bytes vom Anfang gesetzt
//   f.seek(100,SeekCur);                                       // SeekCur -> aktuelle Position wird um "offset" Bytes verschoben
     f.seek(100,SeekEnd);                                       // SeekEnd -> Position wird auf "offset" Bytes vom Ende der Datei desetzt
//   Serial.println(f.position());                              // Aktuelle Position bestimmen
  }                            

  String Zeile = "";
    while (f.available()){                                    // so lange noch daten kommen ist die Schleife aktiv
        Zeile = f.readStringUntil('\n');                      // es wird bis zum Zeilenende (\n) alles ausgelesen
    }                                                         // nach der letzten zeile wird die Schleife beendet
    
  Serial.println("inhalt der letzten Zeile");
  Serial.println(Zeile);                                      // die zuletzt gestreamte Zeile ist im String gespeichert

// *** Hier wird eine bestimmte Spalte aus der letzten Zeile extrahiert

  int StartPunkt    =0;                                       // Startposition der Spalte
  int EndPunkt      =0;                                       // Endposition der Spalte

  for(int i=0; i<Spalte; i++){
    
    if (EndPunkt+1 == Zeile.length()) return "angegebene Spaltenanzahl zu hoch";
    if(!i==0) StartPunkt = EndPunkt + 1;                      // für die erste Spalte ist der Startpunkt 0
    EndPunkt = Zeile.indexOf(Trennzeichen,StartPunkt + 1);    // es wird der nächste trennzeichen gesuch die suche beginnt beim letzten
    if (EndPunkt == -1) return "Trennzeichen nicht vorhanden";
    }
  String SpalteX = Zeile.substring(StartPunkt,EndPunkt);      // der String vom Startpunkt (inklusive) bis zum Endpunkt (exklusive) extrahiert
 
  f.close();

  return SpalteX;
}

[Matthias L. (lindner8712)]

Hallo,

Sieht doch gut aus,
Persönlich find ich den Ansatz einfach vom Ende weg mit Offset zu suchen 
richtig gut.

Die ursprüngliche Methode war eben deswegen unschön da die gesamte Datei 
gelesen werden muss um das Ende bzw. Letzte Zeile zu erreichen.

Das hast aber mit f. Seek schön umgangen :-)

Zum Thema blockierungsfrei: ich denke du sprichst hier von yield(), 
delay() und Wdt_feed(). Die geben aber nur der CPU Zeit ihre eigenen 
Protokolle abzuarbeiten.

Grüße