Problem mit Einlesen von seriellen Daten am RX vom Arduino

[Georg M. (georg_m)]

Guten Morgen :)

ich hab ein kleines Problem mit dem einlesen der Daten am seriellen 
Eingang meines Arduino Mega 2560.
Ich Überwache den seriellen Eingang RX2 ob Daten verfügbar sind. Dabei 
handelt es sich um seriell weitergeleitete Telegramme  eines TCM320 
Transceivers.
Das Einlesen klappt auch alles wunderbar, solange ich beim überprüfen 
von "Serial2" ein delay von 2 ms in die While-Schleife einbaue. Nehme 
ich dies delay raus, kommt es bei einer bestimmten Verzögerung zwischen 
zwei empfangenen Telegrammen zum Verlust des zweiten Telegramms.

Ein Telegramm besteht aus 38 Byte. Den Ringspeicher der seriellen 
Schnittstelle habe ich bereits auf 256 Byte erhöht. Damit bei zu schnell 
eingehenden Telegrammen das erste nicht wieder überschrieben wird, wenn 
das Bard mit dem auslesen nicht nachkommt.

Aber warum brauche ich das delay von 2 ms??? Bin vollkommen ratlos.

Hier mein Code.

#include "klasse.h"

uint8_t data[200]={0};
int dataLen=0;
int ausgabe=false;

Prototype klasse;

void setup()
  {
    Serial.begin(115200);
    Serial2.begin(57600);
  } 

void loop()
  {

  }
  
  
  void serialEvent2()
  {
    int sizeofdata=0;
    while(Serial2.available())
    {
      //Zwischenpeichern der Daten in einem Array aus dem Ringspeicher
      data[dataLen] =Serial2.read();
      Serial.print(data[dataLen],HEX);
      Serial.print(",");
      delay(2);
      dataLen++;
      //delay(2);
      if(dataLen >= 4)
      {
        //überwacht die Telegrammgröße
        sizeofdata=data[1]+data[2]+data[3]+7;       
      }
      if((dataLen == sizeofdata)&& (sizeofdata != 0))
      { 
        //speichern der Daten erfolgt nur, wenn Telegramm komplett 
        klasse.speichern(data);
        dataLen=0;
        break;
      }
    }
  }

[Karl H. (kbuchegg)]

Georg M. schrieb:

> Aber warum brauche ich das delay von 2 ms???

Weil du hier in dieser Schleife ...

    while(Serial2.available())
    {
      //Zwischenpeichern der Daten in einem Array aus dem Ringspeicher
      data[dataLen] =Serial2.read();

...
    }

davon ausgehst, dass du ein komplettes Telegram damit abarbeiten kannst. 
Dem ist aber nicht so. Dein µC rechnet viel schneller, als die USART 
übertragen kann. D.h. die available Schleife ist zu Ende und das 
Telegram ist noch gar nicht vollständig reingekommen.

Beim nächsten Zeichen des Telegramms, welches du mitten drinn 
abgebrochen hast, wird zwar die Event Funktion wieder aufgerufen. Aber 
zu diesem Zeitpunkt hast du die Variable sizeofdata schon verloren (weil 
es eine lokale Variable ist) und keine Ahnung mehr, wieviele Zeichen 
eigentlich noch fehlen, bis dieses eine Telegramm fertig ist.


Baust du dagegen den delay ein, dann zwingst du den µC dazu Zeit zu 
vertrödeln. Zeit, in der die Gegenstelle wieder ein Zeichen per UART 
übertragen kann, welches dann dazu führt, dass available() wieder ein 
Zeichen für den read() hat, wodurch die while-Schleife weiterläuft bis 
dann irgendwann sizeofdata Zeichen bearbeitet wurden.

> Damit bei zu schnell eingehenden Telegrammen

:-) Das genaue Gegenteil ist der Fall. Der µC ist viel schneller, als 
die Gegenstelle senden kann.