Nextion Component ID trennen

Hallo,
ich habe hier so meine richtigen Probleme mit der seriellen Verarbeitung
Arduino/Nextion.
Ich habe einen NextionButtom der nur seine ID (65000301FFFFFF)ausgibt.
Das Nextion gibt diese auch an CoolTerm so aus.
Mit meinem Sketch bekomme ich,

65
0
3
1
FFFFFFFF
FFFFFFFF
FFFFFFFF

heraus. Das sieht gut aus, anfangen kann ich damit aber nichts.
Wie bekomme ich das denn getrennt.
also,

65

00

03

01

ich hätte das schon gerne NICHT- als String.
Möchte mir da einmal jemand helfen.

Meinen Sketch halte ich eigenlich im Grunde gut dafür. Ich weiß nur nicht,
was ich ändern sollte.
Er findet auch kein EndeTerminator.
Gruß und Dank
Andreas

Sketch

#include <Wire.h>

const int SERIAL_BUFFER_SIZE = 20;
char serialBuffer[SERIAL_BUFFER_SIZE];

void setup()
{
  Serial.begin(9600);
  Serial3.begin(19200);//Nextion
}

void loop()
{
  if (Serial3.available() > 0)
  {
    if (readSerial(Serial3) == true);
    {
      NexSer();
    }
  }
}

bool readSerial(Stream& stream)
{

  static byte index;

  while (stream.available())
  {
    char c = stream.read();

   
    Serial.println(c,HEX);
     

    if (c,HEX >= 20 && index < SERIAL_BUFFER_SIZE - 1)
    {
      serialBuffer[index++] = c,HEX;
//Serial.println(c,HEX);

    }
    else

      if ((c,HEX == 'FF' || c == '\r') && index > 0)

      {
        Serial.println("aussteigen");
        serialBuffer[index] = '\0';
        index = 0;
        return true;
      }
  }
  return false;
}

//*********************************************************************    Nextion Abfrage seriell

void NexSer()
{
  //mache etwas
}

Du erfasst nur das erste 0xFF, der Rest bleibt in der Queue.

Welche ID der Button hat, weißt Du ja, Du hast ihn ja programmiert.
Oder ist Deine Frage eine andere?

Gruß Tommy

Hallo Tommy,
ich erfasse alles, das ist ja das Problem...
Der Buttom sendet 65000301FFFFFF

Ich hätte jetz gerne ausgewertet als HEX

die
65
die
00
die
03
und die 01

ich schaffe es nicht einmal FF mit meinem Sketch abzufangen.
Also als Ausgabe nur 65000301. Vielleicht würde ich damit dann schon alleine weiterkommen.
Gruß und Dank
Andreas

Was soll denn der Quatsch?

if (c,HEX >= 20

Der Komma Operator macht nicht was du denkst. Bei print() ist Hex einfach ein Parameter der Funktion. Das kannst du an keiner anderen Stelle verwenden

Wenn du eine Zahl als Hex angeben willst geht das so:

if (c >= 0x20)

Beim Endzeichen musst du eigentlich mitzählen wie oft 0xFF da war und beim dritten mal aufhören

Getrennt ist da ja schon. Die hast jede Zahl in einem eigenen Array Index. Du kommt eher mit der Darstellung der Zahlen durcheinander. Ein Computer kennt eigentlich kein Hexadezimal. Das ist nur eine Schreibweise für Menschen um Binärzahlen leichter zu lesen

Hallo,
das “if (c >= 0x20)” und vor allem das “eigenen Array Index” hat mir auf die Sprünge geholfen.

Dann habe ich dieses “HEX” rausgenommen, und aus dem “char c” ein “int c” gemacht. Ich hasse es, wenn man mit Zahlen
arbeitet, da “Buchstaben” draus zu machen.
Dann habe ich einen Zähler gesetzt der mir die empfangenen Daten zerlegt.

Bis jetzt funktioniert das eigentlich. Was mich stört ist derTerminator “FF”. Der kommt eigentlich 3x.
Denn bekomme ich aber nicht zu fassen. Ist da etwas zu schnell oder zu langsam?

Ganz wohl ist mir ja nicht, aber ich glaube es ist ziemlich sicher.
Wie könnte ich denn dort Fehler abfangen?
Kann man das ganze eleganter lösen, ohne"BuchstabenSalat"?

Ausgabe Serieller Monitor:

Touch-Event....101
aktuelle Seite 0
ID             3
ausgeloest 0/1 1
Terminator 3   255
Touch-Event....101
aktuelle Seite 0
ID             3
ausgeloest 0/1 1
Terminator 3   255
Touch-Event....101
aktuelle Seite 0
ID             3
ausgeloest 0/1 1
Terminator 3   255
Touch-Event....101
aktuelle Seite 0
ID             3
ausgeloest 0/1 1
Terminator 3   255

ich finde das sieht schon gut aus…

der Sketch:

#include <Wire.h>

const int SERIAL_BUFFER_SIZE = 20;
char serialBuffer[SERIAL_BUFFER_SIZE];
int zlTest;
int c;
static byte index;
void setup()
{
  Serial.begin(19200);
  Serial3.begin(19200);//Nextion
}

void loop()
{
  if (Serial3.available() > 0)
  {
    if (readSerial(Serial3) == true);
    {
  
      NexSer();
  
    }
  }
}

bool readSerial(Stream& stream)
{

  

  while (stream.available())
  {
     c = stream.read();

   zlTest++;
   
/*    Serial.print(c);
    Serial.println();
Serial.print("Test ");
Serial.println(zlTest);
*/
    if (c >= 32 && index < SERIAL_BUFFER_SIZE - 1)
    {
      serialBuffer[index++] = c;
 


    }
    else

      if ((c >= '\n' || c == '\r') && index > 0)

      {
        Serial.println("aussteigen");
        serialBuffer[index] = '\0';
        index = 0;
        return true;
      }
  }
  return false;
}
//e\x00\x03\x01ÿÿÿ
//*********************************************************************    Nextion Abfrage seriell

void NexSer()
{
  if (zlTest == 1)
   {
  Serial.print("Touch-Event....");
  Serial.println(c);
  }

  if (zlTest == 2)
   {
  Serial.print("aktuelle Seite ");
  Serial.println(c);
}

  if (zlTest == 3)
   {
  Serial.print("ID             ");
  Serial.println(c);
}

  if (zlTest == 4)
   {
  Serial.print("ausgeloest 0/1 ");
  Serial.println(c);
}

  if (zlTest == 5)
   {
  Serial.print("Terminator 1   ");
  Serial.println(c);
}

 if (zlTest == 6)
   {
  Serial.print("Terminator 2   ");
  Serial.println(c);
}

   if (zlTest == 7)
   {
  Serial.print("Terminator 3   ");
  Serial.println(c);
  }
  
  if (zlTest >= 6)
   {
  zlTest = 0;
   index = 0;
  }
  
  }

wird das eigentlich noch gebraucht?

 if (c >= 32 && index < SERIAL_BUFFER_SIZE - 1)
    {
      serialBuffer[index++] = c;
 


    }
    else

      if ((c >= '\n' || c == '\r') && index > 0)

      {
        Serial.println("aussteigen");
        serialBuffer[index] = '\0';
        index = 0;
        return true;
      }
  }
  return false;

das Ding hat mich Nerven gekostet…
Gruß und Dank
Andreas

    if (c >= 32 && index < SERIAL_BUFFER_SIZE - 1)
    {
      serialBuffer[index++] = c;
    }
    else

      if ((c >= '\n' || c == '\r') && index > 0)

      {
        Serial.println("aussteigen");
        serialBuffer[index] = '\0';
        index = 0;
        return true;
      }
  }
  return false;

Wozu soll der \r und \n Kram gut sein?

Warum benutzt du nicht etwas das funktioniert?

Whandall:
Es geht auch etwas hübscher:

#include <WhandallSerial.h>  // https://github.com/whandall/WhandallSerial

// simple handler just prints some infos about the received line

void processLine(const char* buf) {
  Serial.print(F("len = “));
  Serial.print((uint8_t)buf[-1]);
  Serial.print(F(”, strlen = “));
  Serial.print(strlen(buf));
  Serial.print(F(”, "));
  dump(buf, buf[-1]);
}

void processConsoleLine(const char* buf) {
  Serial.print(F(“sent “”));
  Serial.print(buf);
  Serial.println(F(”""));
  Serial1.print(buf);
  Serial1.write(0xFF);
  Serial1.write(0xFF);
  Serial1.write(0xFF);
}

SSerial console(Serial, processConsoleLine); // used serial and handler
SSerial nextionSerial(Serial1, processLine); // used serial and handler

void setup() {
  Serial.begin(250000);
  console.begin(64, optIgnoreLF); // buffer size and options
  Serial1.begin(115200);
  nextionSerial.begin(64, optTripleFF | optKeepDlm); // buffer size and options
}

void loop() {
  console.loop();        // collect chars and call handler for each line
  nextionSerial.loop();  // collect chars and call handler for each line
}

void dump(const void* ptr, int len) {
  const byte* adr = (const byte*) ptr;
  byte idx;
  if (len) {
    for (; len > 0; len -= 16, adr += 16) {
      for (idx = 0; (idx < 16) && (idx < len); idx++) {
        phByte(adr[idx]);
        Serial.write(’ ‘);
      }
      Serial.write(’"’);
      for (idx = 0; (idx < 16) && (idx < len); idx++) {
        Serial.write(adr[idx] < 0x20 ? ‘.’ : adr[idx]);
      }
      Serial.write(’"’);
      Serial.println();
    }
  }
}

void phByte(byte byt) {
  if (byt < 16) {
    Serial.write(‘0’);
  }
  Serial.print(byt, HEX);
}





sent “get bkcmd”
len = 8, strlen = 2, 71 03 00 00 00 FF FF FF “q…⸮⸮⸮”
sent “page 1”
len = 4, strlen = 4, 01 FF FF FF “.⸮⸮⸮”
len = 5, strlen = 5, 66 01 FF FF FF “f.⸮⸮⸮”
sent “page 0”
len = 4, strlen = 4, 01 FF FF FF “.⸮⸮⸮”
len = 5, strlen = 1, 66 00 FF FF FF “f.⸮⸮⸮”

Hallo,
ich habe mir das halbwegs selbst zusammen geklickt. So viel Ahnung habe
ich davon noch nicht.

“Warum benutzt du nicht etwas das funktioniert?”
Das, #include <WhandallSerial.h>, ist ein Grund. Ich mag keine Libs.
Wenn möglich fliegen die Raus.

“Wozu soll der \r und \n Kram gut sein?”
Ich hatte nachgefragt, ob das noch gebraucht wird. Sieht wohl so aus,
als könne das rausfliegen?

Gruß und Dank
Andreas

SkobyMobil:
Ich mag keine Libs. Wenn möglich fliegen die Raus.

Ich mag es nicht dauernd den gleichen Kram zu tippen oder zusammen zu kopieren,
mir reicht es ein Problem einmal zu lösen.

Libraries sind einfach eigenständige Programmbestandteile,
aber nichts anderes als ganz normaler Kode.

Mal abgesehen von der Verwendung, kannst du in dieser Library sehen,
wie es für normale serielle Kommunikation und Nextion mit dem gleichen Kode funktionieren kann.

Und abgesehen von deinen Vorlieben: dein Kode funktioniert nicht.

Keine Library gewünscht?

Kein Problem, der Übersichtlichkeit nützt das aber nicht.

Jetzt für Serial Konsole mit 250000 (nein, deine 9600 trage ich da nicht ein) Serial3 Nextion mit 19200.
Ich betreibe meine Nextions mit 115200, aber das ist wohl auch Geschmacksache.

enum {
  cbLF = 10,
  cbCR = 13,
  cbNX = 0xFF,
  /// LineFeed ignorieren
  optIgnoreLF = 0x40,
  /// Leerzeichen am Zeilenanfang unterdrücken
  optSkipWS = 0x20,
  /// Aktion auch für Leerzeilen ausführen
  optEmptyToo = 0x10,
  /// Nextion Format (Delimiter: 3 x 0xFF) verwenden
  optTripleFF = 0x08,
  /// Delimiter im Puffer belassen (also mit übergeben)
  optKeepDlm = 0x04,
  /// Debug Ausgaben auf Serial
  optDebug = 0x02,
  /// detailiertere Debug Ausgaben aus Serial
  optDebugDetail = 0x01,
};

typedef void (*lineProcess)(const char* iLine);
class SSerial {
  protected:
    Stream& serial;
    uint8_t options;
    uint8_t bSize;
    uint8_t bIndex;
    uint8_t* buffer;
    lineProcess handler;
  public:
    SSerial(Stream& inSer, lineProcess iHandler) : serial(inSer), handler(iHandler) {}
    ~SSerial() {
      delete [] --buffer;
    }
    void begin(uint8_t maxMessage, uint8_t inOpts = optIgnoreLF);
    void loop();
    uint8_t* getBuffer() {
      return buffer;
    }
    uint8_t getIndex() {
      return bIndex;
    }
    uint8_t getSize() {
      return bSize;
    }
    void static blankAndHex(uint8_t inB);
};

// simple handler just prints some infos about the received line

void processLine(const char* buf) {
  Serial.print(F("len = "));
  Serial.print((uint8_t)buf[-1]);
  Serial.print(F(", strlen = "));
  Serial.print(strlen(buf));
  Serial.print(F(", "));
  dump(buf, buf[-1]);
}

void processConsoleLine(const char* buf) {
  Serial.print(F("sent \""));
  Serial.print(buf);
  Serial.println(F("\""));
  Serial3.print(buf);
  Serial3.write(0xFF);
  Serial3.write(0xFF);
  Serial3.write(0xFF);
}

SSerial console(Serial, processConsoleLine); // used serial and handler
SSerial nextionSerial(Serial3, processLine); // used serial and handler

void setup() {
  Serial.begin(250000);
  console.begin(64, optIgnoreLF); // buffer size and options
  Serial3.begin(19200);
  nextionSerial.begin(64, optTripleFF | optKeepDlm); // buffer size and options
}

void loop() {
  console.loop();         // collect chars and call handler for each line
  nextionSerial.loop();   // collect chars and call handler for each line
}

void dump(const void* ptr, int len) {
  const byte* adr = (const byte*) ptr;
  byte idx;
  if (len) {
    for (; len > 0; len -= 16, adr += 16) {
      for (idx = 0; (idx < 16) && (idx < len); idx++) {
        phByte(adr[idx]);
        Serial.write(' ');
      }
      Serial.write('"');
      for (idx = 0; (idx < 16) && (idx < len); idx++) {
        Serial.write(adr[idx] < 0x20 ? '.' : adr[idx]);
      }
      Serial.write('"');
      Serial.println();
    }
  }
}

void phByte(byte byt) {
  if (byt < 16) {
    Serial.write('0');
  }
  Serial.print(byt, HEX);
}

void SSerial::begin(uint8_t maxMessage, uint8_t inOpts) {
  options = inOpts;
  bSize = maxMessage;
  buffer = new uint8_t[bSize + 2];  // one uint8_t for the trailing '\0', one for the prefix len uint8_t
  if (buffer == NULL) {
    bSize = 0;
  } else {
    buffer++;
  }
  bIndex = 0;
}

void SSerial::blankAndHex(uint8_t inB) {
  Serial.write(' ');
  if (inB < 16) {
    Serial.write('0');
  }
  Serial.print(inB, HEX);
}

void SSerial::loop() {
  bool doCheck = false;

  while (serial.available()) {  // allows usage of continue/break
    uint8_t inChar = serial.read();
    if (options & optDebug) {
      if (options & optDebugDetail) {
        blankAndHex(bIndex);
        Serial.write(':');
      }
      blankAndHex(inChar);
      if (options & optDebugDetail) {
        Serial.println();
      }
    }
    if (inChar == cbLF && options & optIgnoreLF && !(options & optTripleFF)) {
      continue;
    } else if (inChar == cbCR && !(options & optTripleFF)) {
      if (options & optKeepDlm) {
        buffer[bIndex++] = inChar;
      }
      // pass up only if non empty, or empty requested
      doCheck = bIndex || (options & optEmptyToo);
    } else if ((options & optTripleFF) && inChar == 0xFF &&
               (bIndex >= (*buffer == 0x71 ? 7 : 2)) &&
               buffer[bIndex - 1] == 0xFF && buffer[bIndex - 2] == 0xFF) {
      if (options & optKeepDlm) {
        // store in buffer, advancing index
        buffer[bIndex++] = inChar;
      } else {
        // index of first 0xFF
        bIndex -= 2;
      }
      // pass up only if non empty, or empty requested
      doCheck = bIndex || (options & optEmptyToo);
    } else {
      // skip whitespace on line start
      if ((bIndex == 0) && (isWhitespace(inChar) || (inChar == cbLF)) && (options & optSkipWS)) {
        continue;
      }
      // store in buffer, advancing index
      buffer[bIndex++] = inChar;
      // passup if filled
      doCheck = (bIndex == bSize);
    }
    if (doCheck) {
      buffer[bIndex] = 0; // make buffer a string
      if ((options & optDebug) && ~(options & optDebugDetail)) {
        Serial.println();
      }
      buffer[-1] = bIndex;
      (*handler)((const char*)buffer);  // pass to handler
      bIndex = 0;     // empty buffer
    }
  }
}

SkobyMobil:
und aus dem “char c” ein “int c” gemacht. Ich hasse es, wenn man mit Zahlen arbeitet, da “Buchstaben” draus zu machen.

Nein, nein. “char” sind nicht unbedingt Buchstaben. Für einen Computer sind das alles Zahlen. “char” ist einfach ein Byte mit Vorzeichen. Wenn du keine Buchstaben hast will du eher “unsigned char”. Den Typ “byte” gibt es in C/C++ nicht. Das ist von der Arduino IDE und einfach ein typedef auf “unsigned char”

Wenn du so grundlegende Verständnis-Probleme hast ist es vielleicht nicht gut das komplett selbst zu machen

Generell solltest du halt mal überlegen ob du hier Binärdaten oder Strings hast. Der Code von mir ist dazu da C Strings einzulesen. F+r was anderes muss man das klar anpassen.
Und wenn man keine Null-Terminierung hat, sollte man wahrscheinlich melden wie viele Zeichen tatsächlich eingelesen wurden

wird das eigentlich noch gebraucht?

if (c >= 32 && index < SERIAL_BUFFER_SIZE - 1)

c >= 32 ist dazu da ASCII Steuerzeichen zu unterdrücken. Also nur für Strings

Man muss natürlich immer noch verhindern dass über den Puffer hinausgeschrieben wird. Das -1 ist allerdings da damit der Null-Terminator noch Platz hat. Bei Binärdaten kann das also weg

Wenn du keine Buchstaben hast will du eher "unsigned char"

Statt byte kann man auch uint8_t schreiben. Das ist eindeutig und ein C++ Standard-Datentyp.
Und hat nichts mit Buchstaben zu tun.

Ach Serenifly,
ich habe das schon verstanden. Vielleicht habe ich mich auch nicht richtig ausgedrück.

Mein Sketch läuft eigentlich- genau so lange, wie man nichts anderes macht, als den Button zu drücken.
Macht man dann leichtsinnerweise etwas anderes, macht der Sketch es auch- aber richtig!
Läuft völlig aus dem Ruder. Die ganze Quälerei für die Katz. So ein Dreck.

Das sind doch nur wenige Zeichen die da übertragen werden, das kann doch nicht sein, das man dafür
Ellenlangen Code benötigt.

Wenn man das (65000301FFFFFF) zelegt, dann sind es gerade mal 7 Blöcke.
Ein Zähler bis 6 würde also reichen. Aber das macht mein Zähler nicht.

Mir schwant ja böses... das Zeugs liegt ja in einen byte Array. Und das ist bit und byte Schieberei.
Davon habe ich überhaupt keine Ahnung. Ich wüßte nicht einmal wo ich da ansetzen sollte.

Ich habe ja das

void loop()
{
  if (Serial3.available() > 0)
  {
    if (readSerial(Serial3) == true);
    {
      NexSer();
    }
  }
}

bool readSerial(Stream& stream)
{

  static byte index;

  while (stream.available())
  {
    char c = stream.read();

   
    Serial.println(c,HEX);
     
}

hiermit mache ich genau das sichtbar was ich haben möchte. Das aber zu zählen und zu zerlegen
funktioniert aber nicht bei mir, jedenfalls nicht sicher.
Gruß und Dank
Andreas

Hallo Michael,
so..

while (stream.available())
  {
     uint8_t c = stream.read();

   zlTest++;
   }

Würde er dann für 65HEX, 0110 0101 lesen?
Gruß und Dank
Andreas

Ich bekomme ja 65 00 03 01 FF FF FF
Wenn ich jetzt die "03" haben möchte, muß ich dann bis 2 zählen
und bekomme 0000 0011?
Gruß und Dank
Andreas

Du kannst doch wie beim Einlesen eines Strings das auch in einem Array abspeichern. Es gibt nur zwei Unterschiede:
1.) Die End-Kennung ist anders. Du kannst z.B. wie Whandall wenn 0xFF kommt die zwei Indizes davor anschauen ob da auch 0xFF drin steht
2.) Da man keinen Terminator hat sollte man angeben wie viele Bytes eingelesen wurden

SkobyMobil:
Ich bekomme ja 65 00 03 01 FF FF FF

0x65 = Kennung für Touchevent
0x00 = Page
0x03 = Component-ID
0x01 = Event (1 = Touch, 0 = Release)
0xFF 0xFF 0xFF = Endekennung

Wenn Du ab 0x65 im Array speicherst, hat die 0x03 den Index 2.

Gruß Tommy

Edit: Returncodes

#define nxSerial Serial3

struct TouchEvent {
  byte id; // 0x65
  byte page;
  byte componentId;
  byte event;
  void disp() {
    if (id != 0x65) {
      Serial.println(F("No TouchEvent"));
    } else {
      Serial.print(F("TouchEvent: page "));
      Serial.print(page);
      Serial.print(F(", id "));
      Serial.print(componentId);
      Serial.print(F(", event "));
      Serial.println(event ? F("PRESS") : F("RELEASE"));
    }
  }
};

void processLine(const char* buf) {
  ((TouchEvent*)buf)->disp();
}

typedef void (*lineProcess)(const char* iLine);

class NXSerial {
  protected:
    Stream& serial;
    uint8_t bSize;
    uint8_t bIndex;
    uint8_t* buffer;
    lineProcess handler;
  public:
    NXSerial(Stream& inSer, lineProcess iHandler) : serial(inSer), handler(iHandler) {}
    ~NXSerial() {
      delete [] --buffer;
    }
    void begin(uint8_t maxMessage) {
      bSize = maxMessage;
      buffer = new uint8_t[bSize + 2];  // one uint8_t for the trailing '\0', one for the prefix len uint8_t
      if (buffer == NULL) {
        bSize = 0;
      } else {
        buffer++;
      }
      bIndex = 0;
    }
    void loop() {
      bool doCheck = false;
      while (serial.available()) {  // allows usage of continue/break
        uint8_t inChar = serial.read();
        if (inChar == 0xFF &&
            (bIndex >= (*buffer == 0x71 ? 7 : 2)) &&
            buffer[bIndex - 1] == 0xFF && buffer[bIndex - 2] == 0xFF) {
          buffer[bIndex++] = inChar;
          doCheck = true;
        } else {
          buffer[bIndex++] = inChar;
          doCheck = (bIndex == bSize);
        }
      }
      if (doCheck) {
        buffer[bIndex] = 0;
        buffer[-1] = bIndex;
        (*handler)((const char*)buffer);
        bIndex = 0;
      }
    }
} nextionSerial(nxSerial, processLine);

void setup() {
  Serial.begin(250000);
  nxSerial.begin(19200);
  nextionSerial.begin(64); // buffer size
}

void loop() {
  nextionSerial.loop();
}
TouchEvent: page 0, id 6, event RELEASE
TouchEvent: page 0, id 3, event RELEASE
TouchEvent: page 0, id 1, event RELEASE
TouchEvent: page 0, id 9, event RELEASE
TouchEvent: page 0, id 10, event RELEASE
TouchEvent: page 0, id 11, event RELEASE
TouchEvent: page 0, id 12, event RELEASE
TouchEvent: page 0, id 13, event RELEASE

Oder nahezu OOP frei, ohne Library, mit nahezu minimalem Kode.

const byte bufferSize = 64;

void setup() {
  Serial.begin(250000);
  Serial3.begin(19200);
}

void loop() {
  static uint8_t bIndex;
  static uint8_t buffer[bufferSize];
  bool allesDa = false;
  if (Serial3.available()) {
    uint8_t inChar = Serial3.read();
    if (inChar == 0xFF &&  (bIndex >= (*buffer == 0x71 ? 7 : 2)) &&
        buffer[bIndex - 1] == 0xFF && buffer[bIndex - 2] == 0xFF) {
      buffer[bIndex++] = inChar;
      allesDa = true;
    } else {
      buffer[bIndex++] = inChar;
      allesDa = (bIndex == bufferSize);
    }
  }
  if (allesDa) {
    if (*buffer != 0x65) {
      Serial.println(F("No TouchEvent"));
    } else {
      Serial.print(F("TouchEvent: page "));
      Serial.print(buffer[1]);
      Serial.print(F(", id "));
      Serial.print(buffer[2]);
      Serial.print(F(", event "));
      Serial.println(buffer[3] ? F("PRESS") : F("RELEASE"));
    }
    bIndex = 0;
  }
}
TouchEvent: page 0, id 5, event RELEASE
TouchEvent: page 0, id 9, event RELEASE
TouchEvent: page 0, id 2, event RELEASE
TouchEvent: page 0, id 13, event RELEASE
TouchEvent: page 0, id 11, event RELEASE
TouchEvent: page 0, id 10, event RELEASE

Eine Zeile ließ sich noch entfernen.

const byte bufferSize = 64;

void setup() {
  Serial.begin(250000);
  Serial3.begin(19200);
}

void loop() {
  static uint8_t bIndex;
  static uint8_t buffer[bufferSize];
  bool allesDa = false;
  if (Serial3.available()) {
    uint8_t inChar = Serial3.read();
    buffer[bIndex++] = inChar;
    if (inChar == 0xFF && (bIndex >= (*buffer == 0x71 ? 8 : 3)) &&
        buffer[bIndex - 2] == 0xFF && buffer[bIndex - 3] == 0xFF) {
      allesDa = true;
    } else {
      allesDa = (bIndex == bufferSize);
    }
  }
  if (allesDa) {
    if (*buffer != 0x65) {
      Serial.println(F("No TouchEvent"));
    } else {
      Serial.print(F("TouchEvent: page "));
      Serial.print(buffer[1]);
      Serial.print(F(", id "));
      Serial.print(buffer[2]);
      Serial.print(F(", event "));
      Serial.println(buffer[3] ? F("PRESS") : F("RELEASE"));
    }
    bIndex = 0;
  }
}

Hallo Whandall,
ist ja nett, das Du Dir hier so viel Mühe gibst. Bringt mir aber leider nichts.
Dein Sketch läuft genau so gut, wie meiner. Zum einem gibt es nicht alles aus- (65 00 03 01 FF FF FF) das wollte ich ja haben,
zum anderem kommt er ins haspeln, wenn man ein anderes Objekt am Nextion aktiviert.
Zuerst wird nichts gefunden und dann sporadisch die Informationen.

Das ist vielleicht ein Dreck, es kann doch wohl nicht so schwer sein, einige binäre Daten zu lesen. Ich hatte das ja schon raus
bekommen. Nur am selektieren ist es gescheitert. Das muß doch sicher zum laufen bekommen zu sein.
Gruß und Dank
Andreas