Dateneinlesen vom Nextion endet bei 63 Byte

Hallo zusammen,

ich betreibe Grundlagenforschung (für mich) in Sachen Datenübertragung.

Im Detail:

Die Hardware besteht aus (momentan) einem UNO mit einem Nextion-TFT-Display (intelligent).

Einige Werte von Slidern und die Schaltzustände div. Schalter speichere ich im EEPROM vom Nextion. Beim Verlassen der aktuellen Page speichere ich die Daten weg und beim erneuten Laden hole ich diese wieder auf den Screen und aktualisiere mein GUI.

Nun muss ich den Uno auch synchronisieren, d.h. die Werte aus dem EEPROM einmalig in den Arduino übertragen, z.B. beim Kaltstart oder Reset.

Dazu hat mir Whandall in einem früheren Beitrag schon den Tipp mit dem Befehl ‚rept‘ gegeben.

Mit diesem arbeite ich mein vorliegendes Problem aus.

Im Forum und im www habe ich sehr viel gesucht, gelesen und ausprobiert, da dieses Thema (noch) nicht meine Stärke ist.

Zunächst hänge ich an der vollständigen Übertragung der Werte an den Arduino.

Das Problem ist, dass ich Daten nur bis ca. 70 Bytes einlesen kann.

Alle meine gewünschten Werte habe ich gruppenweise in <60Byte Blöcke überprüft, das ist alles ok.

Da es einmalig reicht, habe ich den Befehl im Setup eingebaut.

Das nachfolgende Beispiel ist aus dem Forum und soll 230Bytes einlesen können.

Bei mir läuft alles soweit gut, aber halt nur bis der 63Byte-Speicher voll ist.

Ich suche schon ziemlich lange, was das für einen Grund haben könnte.

Kann mir hier jemand weiterhelfen?

Gruß und Dank, Franz


// Filename: SerialInput_230Byte_02.ino
// Hardware: Uno mit USB-TTL-Konverter auf Serial2 und Nextion-Editor
// https://forum.arduino.cc/t/solved-serial-data-coming-in-need-to-organize-it-into-data-on-a-screen/617345/4
// Testprogramm zum Austesten des rept-Befehls vom Nextion 
//
// OK: Beispiel fordert Daten vom Nextion an, die Buffersize=250 ist auch ok.
// OK: den gleichen Befehl kann ich über einen Button vom Nextion starten, kein Unterschied
// OK: Daten bis Byte 61 sind immer ok
// OK: den Programmteil mit Overflow habe ich geteset
// der Code liest nur bis Index 68 ein (max. interne Puffergröße)

#include <SoftwareSerial.h>
SoftwareSerial Serial2(2, 3); // RX, TX

//const byte BufferSize = 250;
const unsigned int BufferSize = 250;    // original
char buffer[BufferSize];

void setup()
{
Serial.begin(9600);
Serial2.begin(9600);

//Serial2.print("rept 100,60");
Serial2.print("rept 100,200");
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);   
delay(5);                   // benötigt das Nextion (VerarbeitungsZeit)
Serial.println("setup ok");
}
//-----------------------------------------------
void loop()
{
static bool Storing = false;
static unsigned int Index = 0;

  if(Serial2.available()>0)
    {
      char ch=Serial2.read(); 
      Serial.println((ch),DEC); 
        
        if(Storing)
          {
          if(Index<BufferSize-1)
            {
              Serial.print("BufSize: ");
              Serial.print(BufferSize);   
              Serial.print("     Index ");
              Serial.print(Index);
              Serial.print("  Buf: ");
                               
            buffer[Index++]=ch;
            buffer[Index]=0;
            }
          else
            {
            Serial.println("               Overflow");
            Storing = false;
            Index = 0;          
            }

            
          if(Storing && ch==';')
            {
            ProcessBuffer();  
            Storing=false;
            Index=0;          
            }
          }
        else
          {
          if(strchr("ZETS",ch))
            {
            Storing=true;
            Index=0;
            buffer[Index++]=ch;
            buffer[Index]=0;   
            }
          }
          
        }//end if serial2.available
        
}//end loop
//-----------------------------------------------
void ProcessBuffer()
{
Serial.println(buffer);
switch(buffer[0])
  {
  case 'Z':
    ProcessCells();
    break;
  case 'E':
    ProcessEnergy();
    break;
  case 'T':  //do nothing
    break;
  case 'S':
    ProcessCurrent();
    break;
  }
}
//-----------------------------------------------
void     ProcessCells()
{
Serial.println("process cells");  
}

void ProcessEnergy()
{
Serial.println("process energy");  
}

void  ProcessCurrent()
{
Serial.println("process current");    
}

Das riecht so, als sei deine Ausgabe der Einzelzeichen zu langsam und der FIFO-Buffer läuft dir voll. Versuche doch mal, erst in einen Buffer zu lesen und erst wenn nichts mehr kommt, eine Ausgabe zu machen.

Erhöhe die Geschwindigkeit von Serial,

das gibt u.U. 5 Zeichen für jedes empfangene aus.

Wozu soll die Klammer um ch dienen?

Ich würde erst alle Bytes einlesen, und sie danach verarbeiten.

Ein unglücklicher Name für ein SoftwareSerial Objekt,
der unbedarfte Betrachter sieht dort die dritte Hardware Schnittstelle.

Echt?
Den Empfänger taub machen, ist (gerade für SoftwareSerial) eine besonders doofe Idee.

Hallo Whandall,

ich habe mal

  • auf 115200 umgestellt, der Index läuft bis 77.
  • Delay(5) entfernt, Index läuft bis 77
  • die Ausgabe aus der Schleife entfernt und am Ende eingebaut (eine gute Idee), Index zählt bis 77
  • die Klammer um ch ist ein Überbleibsel:)

Da ich relativ wenig Wissen zum Thema habe, eine Frage:
macht der Originalcode Bytes >230 einlesen denn überhaupt das was er verspricht, nämlich bis zu 230 Bytes einzulesen?

Gruß und Dank, Franz

Mir hat er nichts versprochen, er macht aber deutlich mehr als 230 Bytes einlesen.

Warum zählst du nicht selbst bis 230 (wenn du dir den Buffer in der Größe leisten kannst)?

Abgesehen davon sendet das Nextion nur 200 Bytes.

In deiner Aufzählung hast du

  • dummerweise vergessen den neuen Sketch zu posten

vergessen.

Was ist "deutlich mehr...." in Zahlen? Sag doch mal an.

Das macht ja wohl deutlich mehr, als ein paar Zeichen einsammeln.
In Zahlen kann ich das nicht angeben, ich kann es dir in Zeilen zeigen:

if(Serial.available())
  {
  char ch=Serial.read();  
  if(Storing)
    {
    if(Index<BufferSize-1)
      {
      buffer[Index++]=ch;
      buffer[Index]=0;
      }
    else
      {
      Serial.println("Overflow");
      Storing=false;
      Index=0;          
      }
    if(Storing && ch==';')
      {
      ProcessBuffer();  
      Storing=false;
      Index=0;          
      }
    }
  else
    {
    if(strchr("ZETS",ch))
      {
      Storing=true;
      Index=0;
      buffer[Index++]=ch;
      buffer[Index]=0;   
      }
    }
  }
}

void ProcessBuffer()
{
Serial.println(buffer);
switch(buffer[0])
  {
  case 'Z':
    ProcessCells();
    break;
  case 'E':
    ProcessEnergy();
    break;
  case 'T':  //do nothing
    break;
  case 'S':
    ProcessCurrent();
    break;
  }
}

void     ProcessCells()
{
Serial.println("process cells");  
}

void ProcessEnergy()
{
Serial.println("process energy");  
}

void  ProcessCurrent()
{
Serial.println("process current");    
}