Daten (400 Byte) über altSoftSeriell einlesen und als String auswerten

Hallo Zusammen,
ich bin neu hier und hoffe damit mein erster Beitrag auch richtig "angelegt" ist.

Ich lese über altSoftSeriell (mySerial.readBytes) 400 Byte HEX Daten ein und lege diese in einem Array ab. --> Dast funktioniert soweit

Anschließend gebe ich diese 400 Byte in einer Forschleife im Seriellen Monitor aus
--> Das funktioniert auch soweit ( Nur zu debugg zwecken )

Jetzt möchte ich diese 400 Byte in einen String schreiben und diesen dann wieder im Seriellen Monitor ausgeben ( Nur zu debugg zwecken )
--> Leider wird hier immer nur ein wirrer Teil des gesamten Strings ausgeben warum auch immer

Mein eigentliches Ziel ist aus den 400 Byte Daten nach einem speziellen Muster zu suchen und dann die Stelle aus zugeben an der die Übereinstimmung ist.
--> strcmp

const int empfangs_puffer_groesse = 400;
byte empfangs_puffer[empfangs_puffer_groesse];

int Puffergroesse_Vergleich;

void setup() {
  Serial.begin(19200);
  mySerial.begin(9600);
  while (!Serial) {
    ;  // wait for serial port to connect. Needed for Native USB only
  }
  Serial.println("Initialisierung");
  Puffergroesse_Vergleich = sizeof(start);
  Serial.print("Puffergroesse = ");
  Serial.println(Puffergroesse_Vergleich);
}

//uint8_t gelesen;
bool gelesen;
unsigned int Stromzaehlerstand_int;
bool pruefung_IO;
String temp;
bool packet_gelesen = false;
int b;
int c;
int x;
String Zaehlerwert1;
String Zaehlerwert2;
char chr_Puffer[200];
String str_Puffer;



void loop() {
  packet_gelesen = false;
  str_Puffer = "";
  str_Puffer[0] = '\0';
  //Daten von der Softseriel Schnittstelle einlesen
  if (mySerial.available()) {
    Serial.println("Starte Daten empfangen");
    mySerial.readBytes(empfangs_puffer, empfangs_puffer_groesse);
    packet_gelesen = true;
    Serial.println("Ende Daten empfangen");
  }  //Daten auf Softseriel Schnittstelle verfübar

  //Eingelesene Daten ausgeben
  b = 0;
  if (packet_gelesen == true) {
    Serial.println("Starte Daten ausgeben");
    for (b = 0; b < empfangs_puffer_groesse; b++) {
      HEXprint(empfangs_puffer[b]);
      //strcat(chr_Puffer, empfangs_puffer[b]);
      str_Puffer = str_Puffer + String(empfangs_puffer[b]) + ",";
      //Serial.println("String = " + str_Puffer);
    }  //Eingelesene Daten ausgeben
    Serial.println("");
    Serial.println("String = " + String(str_Puffer));
    Serial.println("Schleifendurchlauefe = " + String(b));
    Serial.println("Ende Daten ausgeben");
    packet_gelesen = false;
  }
  Serial.println("------");
  delay(3000);
}

Warum wird nicht der komplette String angezeigt und warum ist das so willkürlich?

Vielen Dank schon mal für Eure Hilfe

Gruß Frankucx

Was ist das?

Und wo hast du die

eingebunden ?
Du solltest schon den kompletten Sketch posten, wenn wir den prüfen sollen.

Eigentlich solltest du ja wissen, dass IMMER das wichtigste (z.B. die fehlerverursachende Stelle) abgeschnitten wird.
Als Grund kann ich mir nur Langeweile vorstellen.... um den Thread aufregender zu gestalten.

Stimmt, das hat der TO auch fast erreicht.
Zumindest sind ein paar Posts hinzugekommen, die man bei richtiger und vollständiger Fragestellung hätte sparen können. :wink:

Kann es sein, das dir der Speicher ausgeht. Welchen µC hast du?

Vergiss Deinen String, wenn Du nicht weisst, was Du da tatsächlich empfängst!
Dir werden alle Steuerzeichen, oder das, was dafür gehalten wird abgeschnitten und damit allen möglichen Mist ausgegeben.

400 bytes...
Das hört sich danach an, als wäre das ein SML-Stream.

Erzähl mal, was Du da tatsächlich machen willst.
Da gibt es ganz bestimmt schon fertige Lösungen.
Ganz bestimmt.

Mittlerweile frage ich nicht mehr nach dem fehlenden Code.
Und wenn dann so wie in #2
Ein mal, nur ein einziges mal.

Wenn dann nix kommt, bildet sich schnell die Überzeugung, dass der jeweilige TO gar keine Hilfe möchte, sondern nur auf die Kommunikation wert legt.
Aus welchen Gründen auch immer... das ist mir dann egal, bzw. mir meine Zeit zu schade.

Manche werden dann auch sofort stinkig. Auch gut, dann weiß man auf jeden Fall sofort in welche Richtung die Kommunikation gehen soll, in die Eskalation.
Klar habe ich nix gegen eine schöne Eskalation!
Aber doch nicht immer.

Ihr seid echt schnell, so schnell kann ich nicht Anworten

ich habe einen Nano im Einsatz und ja ich möchte das SML auslesen.
Allerdings hat da noch keines auf meine Anwendung gepasst. Irgendwie liefert da kein fertiger Code die Daten ich ich wollte. Ich habe einen MT631 und möchte eigentlich nur den Wert der auch auf dem Display steht auslesen und an meine SPS weiter leiten

Sorry damit ich so langsam bin.
Also das mit sizeof(start) da lese ich nur die größe eines Arrays aus die wird hier aber noch nicht benötigt

Wieso fertiger Code.....selbst schreiben ist angesagt.

Ja das versuche ich ja. In den 400Byte die ich da gelesen habe steht auch das drin das ich wissen will ich muss nur noch die Auswertung hin bekommen und da war die Idee einen String zu erstellen und die Stelle zu finden an der die benötigen Daten stehen. Aber leider steht in dem String nicht das was ich brauche. Aber in dem Array empfangs_puffer[] ist ja eigentlich alles drin

unnötig!

OK aber ich habe bis jetzt keinen anderen Ansatz. Wie könnte ich das sonst umsetzen?
Hast du ne Idee?

Ich hab einen Reader der sich an die DIN Norm hält fertig in einer Alphaphase und ich suche noch weitere Tester. :wink:

Du brauchst erstmal etwas, auf was Du aufbauen kannst.
Hier ist ein Sketch, der Dir einen DUMP liefert

Den brauchst Du nur auf die Pins von Dir umlegen - fertig.
Wenn da was sinnvolles rauskommt, dann können wir weiter machen.

strcmp() memcmp()
Je nach dem...

Der code von dir my_xy_projekt sieht echt gut aus. Aber der läuft auf einem ESP32 oder?
Mein Nano kann den printf befehl so nicht. Ich bin Anfäger mit den Arduinos. Ich muss da mal nach einer alternative vom printf suchen

ich hab irgendwo einen entsprechenden Code für einen AVR.
Notfalls extrahiere ich das nachher aus meinem bestehenden Projekt.

Kleiner Schnipsel.

string my_text = "";

for (b = 0; b < empfangs_puffer_groesse; b++) {
      HEXprint(empfangs_puffer[b]);
      //strcat(chr_Puffer, empfangs_puffer[b]);
      str_Puffer = str_Puffer + String(empfangs_puffer[b]) + ",";

      my_text = my_text + (char)String(empfangs_puffer[b]);   // Hängt das Zeichen an den String dran mit mwandlung 

      //Serial.println("String = " + str_Puffer);
    }  //Eingelesene Daten ausgeben
       Serial.println( my_text );  

Sollte so funktionieren.
Bei mein RFID-Reader tut es die Zeilen jedenfalls :wink:

Das musst du nur noch für dein Serialen Empfang leicht umschreiben.

Gruß

Pucki

nein. eher nicht.
Wie fängst Du ein 0x00 auf?
Es gibt alles fertig. Das Rad muss nicht neu erfunden werden.