Serial Daten bei Komma trennen

[HaWe]

Dafür gibt es seit ewigen Zeiten Hand-Shake-Protokolle.

Das verbreitetste Software-Protokoll ist XON/XOFF, dies verstehen die meisten Geräte mit RS-232 Schnittstelle und es funktioniert mit einer 3-Draht-Verbindung.

Wenn eine komplette RS-232-Schnittstelle vorhanden ist, kann man auch Hardware-Handshake verwenden.

Die meisten Betriebssysteme lesen die Zeichen per Interrupt in einen Ringbuffer ein. Einige Bytes bevor der Ringbuffer überläuft sendet man ein XOFF. Dadurch darf der Sender noch ein paar weitere Zeichen senden ohne, dass diese verloren gehen. Ist dann wieder genügend Platz im Ringbuffer sendet man ein XON. Die Applikation liest dann seine Daten aus dem Ringbuffer.

Beim Senden mach man es auch so. Die Applikation schreibt in einen Buffer. gesendet wird dann per Interrupt. Der Vorteil des Buffers liegt darin, dass die Applikation direkt weiter arbeiten kann nachdem die Daten in den Buffer geschrieben wurden, zumindest so lange noch Platz im Buffer ist.
Beim direkten Schreiben auf die Hardware, muss die Applikation oft warten, bis das letzte Zeichen gesendet ist. Dies verlansamt dann die Rechenzeit für die Anwendung ganz erheblich, wenn niedrige Baudraten verwendet werden.

Typische Programme berechnen zuerst eine Menge (CPU-Zeit) um dann einige Zeichen (Textzeile) auszugeben. Durch die Verwendung von Interrupts bekommt man eine einfache Art von Multitasking hin. Senden, Empfangen und Berechnen sind dann eigene Tasks, welche parallel ablaufen können.

MfG Peter(TOO)

Peter,
statt wieder mal nur Allgemeinplätze und Anekdötchen zu verbreiten: schreib doch lieber nen Arduino-Code hier rein, den der OP wirklich benutzen kann.

[Klebwax]

schreib doch lieber nen Arduino-Code hier rein, den der OP wirklich benutzen kann.

Ich hatte weiter oben vorgeschlagen, die Zeichen im Interrupt zu empfangen und im Interrupthandler den String zu füllen. Da Arduino nicht meine Baustelle ist, hab ich mal nach "arduino UART receive interrupt" gegoogelt. Dabei ist dann als erster Hit dieses herausgekommen:

/*
  Serial Event example

  When new serial data arrives, this sketch adds it to a String.
  When a newline is received, the loop prints the string and clears it.

  A good test for this is to try it with a GPS receiver that sends out
  NMEA 0183 sentences.

  NOTE: The serialEvent() feature is not available on the Leonardo, Micro, or
  other ATmega32U4 based boards.

  created 9 May 2011
  by Tom Igoe

  This example code is in the public domain.

  http://www.arduino.cc/en/Tutorial/SerialEvent
*/

String inputString = "";         // a String to hold incoming data
boolean stringComplete = false;  // whether the string is complete

void setup() {
  // initialize serial:
  Serial.begin(9600);
  // reserve 200 bytes for the inputString:
  inputString.reserve(200);
}

void loop() {
  // print the string when a newline arrives:
  if (stringComplete) {
    Serial.println(inputString);
    // clear the string:
    inputString = "";
    stringComplete = false;
  }
}

/*
  SerialEvent occurs whenever a new data comes in the hardware serial RX. This
  routine is run between each time loop() runs, so using delay inside loop can
  delay response. Multiple bytes of data may be available.
*/
void serialEvent() {
  while (Serial.available()) {
    // get the new byte:
    char inChar = (char)Serial.read();
    // add it to the inputString:
    inputString += inChar;
    // if the incoming character is a newline, set a flag so the main loop can
    // do something about it:
    if (inChar == '\n') {
      stringComplete = true;
    }
  }
}

Mangels eines Arduinos kann ich das nicht testen, es sieht für mich aber ok aus. serialEvent() scheint mir zwar kein wirklicher Interrupthandler zu sein, blockiert aber die Mainloop nicht und hat daher einen ähnlichen Effekt. In der Mainloop kann man, wenn stringComplete true ist, ganz in Ruhe sscanf() oder was auch immer passt einsetzen. Und in serialEvent() kann man sicherstellen, daß der Inputstring nicht durch eine zu lange Zeile überläuft und einen Fehler melden.

MfG Klebwax

[Mxt]

serialEvent()[/B] scheint mir zwar kein wirklicher Interrupthandler zu sein,

Ich habe keinen Überblick über alle Arduino Modelle, aber bei den meisten gibt es einen internen Interrupthandler, der die seriellen Daten in einen internen Puffer kopiert, solange da Platz ist. Beim Teensy 32 oder 64 Byte pro Schnittstelle, bei den kleineren ists wahrscheinlich weniger.

serialEvent wird zwischen den Läufen von loop() ausgeführt, wenn die Funktion definiert ist.

// SerialEvent functions are weak, so when the user doesn't define them,
// the linker just sets their address to 0 (which is checked below).
   ...
#if defined(HAVE_HWSERIAL0)
  void serialEvent() __attribute__((weak));
  ...

Das Beispiel zu serialEvent findet sich übrigens in der IDE.

[HaWe]

die Serial class verwaltet den Serial Puffer , Serial events und Serial timeouts, z.B. bei Serial.readStringUntil(), und sie arbeiten auf AVR, SAM, SAMD, ESP, und sogar Intel Curie und STM (natürlich über verschiedene libs und verschiedene cores).
Es sind also posts sicher nicht so hilfreich für Anfänger, wenn der betreffende Ratgebende seinen Code nicht vorher selber zusammen mit der Arduino IDE auf einem eigenen Arduino testen kann, immerhin ist z.B. die Serial class absolut essentiell.
Da aber viele C/++ Kenner hier sicher einiges zu Arduinisch beitragen könnten, fände ich es durchaus äußerst hilfreich, wenn sie mal 5 EUR für nen Nano oder auch nen nodeMCU investieren würden! 8-)

[Mxt]

Der Grund dafür

und sie arbeiten auf AVR, SAM, SAMD, ESP, und sogar STM (natürlich über verschiedene libs und verschiedene cores).

liegt darin, dass die Serial class nichts davon selbst tut

verwaltet den Serial Puffer , Serial events und Serial timeouts, z.B. bei Serial.readStringUntil(),

Serial ist nur ein kleines Konstrukt, das verschiedene Dinge zusammenbringt.

So ist z.B. readStringUntil gar nicht aus Serial, sondern aus Stream
https://www.arduino.cc/en/Reference/Stream
Das man es in Serial benutzen kann liegt daran, dass ein Serial objekt auch ein Stream ist, durch C++ Vererbung.

Dass ein Serial Objekt mit dem UART des konkreten Arduino sprechen kann, liegt daran, dass es auch ein HardwareSerial Objekt ist. Und unter diesen HardwareSerial Objekten liegen C, nicht C++, Funktionen aus den entsprechenden Arduino Cores, die gibt es für die verschiedene Controller.

Durch diese Architektur gibt es Dinge wie ESP32 in Arduino, weil die diese Dinge einfach mitbenutzen können, obwohl was anderes drunterliegt. Da gibt es nicht die "Super Arduino Entwickler", die das alles zusammenhalten.

[HaWe]

aja, aber wie auch immer die Serial Class gestrickt ist, sie ist jedenfalls ausgesprochen komplex, sei es durch ihre Kernfunktionen oder durch die stream class oder was auch immer da außerdem noch drin steckt. Immerhin werden diese Methoden alle unter der Serial Class gelistet, und für den Arduinisch user ist es ja doch egal, ob Kernfunktion oder Vererbung aus stream:
https://www.arduino.cc/en/Reference/Serial