Arduino Serial ganze wörter abfragen

[max2d (Gast)]

Hallo,

ich möchte an den Arduino über einen PC daten senden und diese 
entsprechend auswerten.

Es soll z.B. P13_ON vom pc gesendet werden, worauf der Arduino Pin 13 
einschaltet.

Ich habe auch schon ein Programm für den Arduino geschrieben, nur leider 
reagiert es nur auch einstellige befehle, also 0-9, oder a-z.
Wie muss ich meine Variable deklarieren dass ich wörter auswerten kann?



Hier mein Code, der auch funktioniert, nur will ich halt statt 1 oder 0 
P13_ON bzw. P13_Off senden.

int ledPin = 13;
int incomingByte;

void setup ()
{
  Serial.begin(9600);
  pinMode (ledPin, OUTPUT);
}

void loop ()
{
   if (Serial.available() >0)
   {
   incomingByte = Serial.read();
    if (incomingByte == '1')
    {
      digitalWrite (ledPin, HIGH);
    }

    if (incomingByte == '0')
    {
      digitalWrite (ledPin, LOW);
    }
}

[Karl H. (kbuchegg)]

max2d schrieb:

> Ich habe auch schon ein Programm für den Arduino geschrieben, nur leider
> reagiert es nur auch einstellige befehle, also 0-9, oder a-z.
> Wie muss ich meine Variable deklarieren dass ich wörter auswerten kann?

Dann lies mal in deinem C++ oder C Buch im Kapitel über 'String' nach.

[Falk B. (falk)]

@ Karl Heinz (kbuchegg) (Moderator)

>Dann lies mal in deinem C++ oder C Buch im Kapitel über 'String' nach.

Oder ein Buch über Quantenphysik, Kapitel "Stringtheorie" ;-)

[stefanus (Gast)]

Schau hier:  http://stefanfrings.de/mikrocontroller_buch/index.html

In Band 2, Kapitel 10.1 und 10.2

Falls Dir das noch zu "hoch" ist, dann lies erstmal die vorherigen 
Programmieranleitungen beginnend ab Band 1.

[foo (Gast)]

Über einen Kommunikationskanal, hier die serielle werden oft "nur 
einstellige Befehle" übertragen. Macht aber nix... Man überlegt sich ein 
Protokoll, oder benutzt ein bestehendes.
Einzelne Befehle werden dann z.B. zu Nachrichten/Messages
Vorteilhaft sind fixe Start und Endmarkierungen.
Z.B: #PxxE+
Könnte heißen # start
P Port
xx Portnummer
E ein, oder A aus
und + Ende

Nun liest du am uc die Einzelbefehle und speicherst sie in einem array, 
oder du fütterst gleich eine Statemachine damit, die das Zeichen 
verarbeitet.
So wie, wenn # dann start, dann muss P kommen usw... wenn die message 
fertig ist port schalten.. wenn dazwischen # wieder von vorne.

[embrio (Gast)]

Hi  max2d,

ich hatte zufällig vor kurzem mit dem selben "Problem" zu kämpfen.

Hier ist mein Lösungsvorschlag:

string cmd; //Befehlsbuffer

void setup() {
  
  //Serielle Datenübertragung starten
  Serial.begin(19200); //USB
  
}

void loop() {
  
  cmd=""; //Buffer "leeren"
  
  if (Serial.available() > 0) {
  int h=Serial.available();   

  for (int i=0;i<h;i++){
    cmd += (char)Serial.read();
    }
  }

  if ( cmd == "LEDon" ) {
    digitalWrite(led, HIGH); //Led einschalten
    Serial.print( cmd + "OK" + "\n" ); //Kommando quittieren
  }

[embrio (Gast)]

Hab mal wieder zu schnell abgesendet.

Die String-Deklaration muss 'String' nachtürlich groß geschrieben werden 
(zumindest in der Arduino-IDE):

String cmd;

und am Ende vom Code fehlt noch ein '}'

[X. Y. (elektro_henkler)]

embrio schrieb:
> Hab mal wieder zu schnell abgesendet.
>
> Die String-Deklaration muss 'String' nachtürlich groß geschrieben werden
> (zumindest in der Arduino-IDE):
>

String cmd;

>
>
> und am Ende vom Code fehlt noch ein '}'

Dein gesamter Code funktioniert nicht, er wird zwar fehlerfrei 
Übertragen, jedoch bleibt dieser ohne funktion

[Karl H. (kbuchegg)]

K. M. H. schrieb:

> Dein gesamter Code funktioniert nicht, er wird zwar fehlerfrei
> Übertragen, jedoch bleibt dieser ohne funktion


Ohne Funktion ist er sicher nicht. Nur ist sowas

  if (Serial.available() > 0) {
  int h=Serial.available();   

  for (int i=0;i<h;i++){
    cmd += (char)Serial.read();
    }
  }

dann halt schon etwas naiv programmiert. Da muss alles 100% klappen. 
Beim kleinsten Fehler kommt dieses 'Protokoll' nie wieder auf die 
'Füsse'.
Mir ist schon klar, dass nach der Möglichkeit der Übertragung von 
Wörtern gefragt war. Und das erfüllt dieser Code eindeutig. Nur gibt es 
bei Übertragungen noch mehr, worauf man achten muss. Aber im Grunde 
stimmt es schon: Ein Wort wird übertragen, indem man Buchstabe für 
Buchstabe überträgt. Klarerweise muss es einen Mechanismus ergeben, mit 
dem der Empfänger feststellen kann, dass ein Wort zu Ende ist. Da gibt 
es mehrere Möglichkeiten, von denen die Vorab-Übertragung der Wortlänge 
sicherlich eine ist.

[Amateur (Gast)]

Am besten Du packst das Ganze in ein einfaches Protokoll.

Also z.B. Jeder Befehl besteht aus ???? gefolgt von einem Zeilenumbruch.

Deine Empfangsroutine empfängt dann "endlos" bis ein Zeilenumbruch 
vorbeikommt. Natürlich kann es an dieser Stelle nicht schaden ein paar 
Überprüfungen der Zeichen und der Anzahl zu machen.

Das Zeilenende Zeichen kannst Du zum Start der Erkennung der 
Zeichenfolge nutzen.

Ab hier gibt es zwei Möglichkeiten:
1. Du zerlegst die Zeichenketten in z.B.  "P", "13", "_" und "ON".
   Damit erschlägst Du Ähnlichkeiten wie: "P", "8", "_" und "ON".
   oder                                   "P", "13", "_" und "OFF".
2. Du legst feste Zeichenketten im FLASH ab und nutzt die
   Vergleichsfunktionen, die C bietet

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

Ooops, jetzt sehe ich es erst.

Das hier
>

>   if (Serial.available() > 0) {
>   int h=Serial.available();
> 
>   for (int i=0;i<h;i++){
>     cmd += (char)Serial.read();
>     }
>   }
>

ist natürlich ziemlicher Unsinn. Man kann nicht davon ausgehen, dass dem 
Programm mittels 'available' die Wortlänge zugespielt wird. In den 
meisten Fällen wird das nicht der Fall sein. 'available' erlaubt 
lediglich eine Aussage darüber, wieviele Zeichen zum Zeitpunkt des 
Funktionsaufrufs bereits übertragen wurden. Aber das müssen ja beileibe 
nicht alle sein. available interessiert sich ja nicht dafür, ob der 
Sender noch Zeichen hat, die er übertragen möchte, die also noch gar 
nicht auf dem Arduino eingelangt sind. Datenübertragung benötigt Zeit! 
Und zwar wesentlich mehr Zeit als Rechenarbeit. Der Ardunio wird also 
viele tausend male drauf kommen, dass 0 Zeichen übertragen wurden, 
unterbrochen von ein paar einzelnen Fällen, in denen 1 Zeichen 
übertragen wurde. Warum? Weil der Rest des Wortes (die restlichen 
Buchstaben) vom Sender noch gar nicht auf die Leitung gegeben wurde.

[Jürgen S. (jurs)]

Karl Heinz schrieb:
> Ohne Funktion ist er sicher nicht. Nur ist sowas
> ...
> dann halt schon etwas naiv programmiert.

Nein, ich als Arduino-Programmierer sage:
Der Code ist völlig ohne Funktion.

Ein Code nach der Logik

if (Serial.available() > 0) {
  // Verarbeite ganz viele Zeichen
}

ist direkt zum Scheitern verurteilt. Damit kann immer nur genau ein 
einziges Zeichen verarbeitet werden, so wie er es macht.

Einen anfängergeeigneten Einlesecode für serielle Befehle unter Arduino 
kann man so machen:

if (Serial.available() > 0) {
  delay(25);
  while (Serial.available()>0) {
    // Verarbeite bis zu 25 Zeichen
  }
}

Wenn das Protokoll dann so aussieht, dass zwischen den einzelnen 
"Befehlen" immer Sendepausen sind, sorgt man mit dem "delay(25)" nach 
dem Empfang des ersten Zeichens dafür, dass noch weitere Zeichen im 
seriellen Eingangspuffer eintreffen. Nach Ablauf von 25 Millisekunden 
kann man diese Zeichen dann aus dem seriellen Eingangspuffer in einem 
Rutsch weg verarbeiten.

Der weiter oben gepostete Code ist ziemlich daneben.
Die unter Arduino möglichen "String-Objekte" wie bei seiner Variablen 
"cmd" verwendet man üblicherweise nicht einmal als 
Arduino-Programmierer, da diese String-Objekte zum Rest der Libraries 
vollkommen inkompatibel sind, und zwar sowohl zur AVR libc Library als 
auch zu fast allen Funktionen der speziellen Arduino-Libraries.

[max2d (Gast)]

> Einen anfängergeeigneten Einlesecode für serielle Befehle unter Arduino
> kann man so machen:
>

> if (Serial.available() > 0) {
>   delay(25);
>   while (Serial.available()>0) {
>     // Verarbeite bis zu 25 Zeichen
>   }
> }
>

Also mein Programm sieht jetzt wie folgt aus:

if (Serial.available () > 0)
{
delay (25);

while (Serial.available () > 0)
{
   if (Serial.read)= == '13On')
   {
     led = true;
   }
}

}

Leider tut sich nichts. Muss ich also doch noch was ändern? Also in 
einen String schreiben wobei:

> Die unter Arduino möglichen "String-Objekte" wie bei seiner Variablen
> "cmd" verwendet man üblicherweise nicht einmal als
> Arduino-Programmierer, da diese String-Objekte zum Rest der Libraries
> vollkommen inkompatibel sind, und zwar sowohl zur AVR libc Library als
> auch zu fast allen Funktionen der speziellen Arduino-Libraries.

mir ja was anderes sagt.

[Karl H. (kbuchegg)]

Jürgen S. schrieb:

> Einen anfängergeeigneten Einlesecode für serielle Befehle unter Arduino
> kann man so machen:
>

> if (Serial.available() > 0) {
>   delay(25);
>   while (Serial.available()>0) {
>     // Verarbeite bis zu 25 Zeichen
>   }
> }
>

>
> Wenn das Protokoll dann so aussieht, dass zwischen den einzelnen
> "Befehlen" immer Sendepausen sind,

Ich will dir nicht zu nahe treten, aber das ist immer noch Quatsch.
In dem Moment, in dem eine serielle Übertragung auf Sendepausen zur 
Synchronisierung beruht, ist das nicht mehr anfängertauglich.

Nicht ohne Grund wird seit Urzeiten auf jedem Keyboard die 
'Return'-Taste verbaut, mit der man dem Rechner andeutet "Ich habe meine 
Eingabe fertig, jetzt bist du dran, sie auszuwerten".
Das ist auch für einen Anfänger der vernünftigste Weg: Jede Übertragung 
wird mit einem speziellen Zeichen als "Jetzt ist alles fertig 
übertragen" markiert. Ob das dann 'Return' ist, oder irgendein anderes 
Zeichen, welches normalerweise nicht vorkommt (HPGL verwendet zb einen 
';' um ein Kommando zu begrenzen), darüber kann man diskutieren. Aber 
nicht über die grundsätzliche Vorgehensweise, wenn Kommandos in Textform 
übertragen werden.

[Karl H. (kbuchegg)]

max2d schrieb:

> Also mein Programm sieht jetzt wie folgt aus:
>

> 
> if (Serial.available () > 0)
> {
> delay (25);
> 
> while (Serial.available () > 0)
> {
>    if (Serial.read)= == '13On')
>    {
>      led = true;
>    }
> }
> 
> }
>

>
> Leider tut sich nichts.

Das wundert mich nicht. Das compiliert noch nicht einmal.
Dieser Code ist sowohl aus Sicht der Behandlung der UART Unsinn, als er 
auch aus ganz banaler C-Syntaxsicht Unsinn ist. Tu dir selbst einen 
Gefallen und kauf dir ein C-Buch (oder ein C++-Buch) und arbeite das 
erst mal auf einem PC durch. Solange du wesentliche Sprachelemente von C 
(bzw. C++) nicht sicher anwenden kannst und einfache 'Algorithmen' 
umsetzen kannst, hat das doch keinen Sinn. Ich schreib 'Algorithmen' 
absichtlich in Hochkomma, weil das ja eigentlich noch kein wirklicher 
Algorithmus ist, der irgendwie schwer ist. Das ist einfach nur: sammle 
Zeichen, bis die Endekennung kommt und wenn die da ist, dann werte die 
gesammelten Zeichen (vulgo: den String) aus, wobei dir die C++ Klasse 
'string' schon mal einen Löwenanteil der tatsächlich schwierigen Arbeit, 
nämlich das Verwalten des Speichers in dem Zeichen gesammelt werden, 
abnimmt. Egal ob das jetzt auf einem kleinen Arduino für den µC 
Schwerarbeit ist oder nicht, für dich als Anfänger ist das erst mal eine 
große Hilfe, also benutze sie auch.

Aus dem Vorschlag von embrio kann man sich schon einiges herleiten bzw. 
ansehen. Wenn auch die Logik etwas verquert ist.

Und lös dich von der Vorstellung, dass irgendwie magisch dein 'Wort' in 
einem Rutsch übertragen wird. Dein 'Wort' wird ganz normal Buchstabe für 
Buchstabe übertragen. Dein Arduino Programm muss die Buchstaben wieder 
zusammensetzen, bis die Kennung kommt 'Wort zu Ende'. Danach kann die 
übertragene Zeichenkette ausgewertet werden. Ja, nicht für alles gibt es 
auf dem Arduino fertige Funktionen, die man einfach nur aufrufen 
braucht. Manchmal muss man doch tatsächlich richtig programmieren.

string cmd; //Befehlsbuffer

void loop()
{
  char nextChar;

  if (Serial.available() > 0) {

    nextChar = Serial.read();

    Serial.print( "Zeichen: '" );
    Serial.print( nextChar );
    Serial.print( "'\n" );

    if( nextChar == ';' ) {
      Serial.print( "Kommando vollständig '" );
      Serial.print( cmd );
      Serial.print( "'\n" );
      
      if( cmd == "LEDon" )
        digitalWrite(led, HIGH);
      else if( cmd == "LEDoff" )
        digitalWrite(led, LOW);
 

      cmd = "";
    }

    else {
      cmd += nextChar;

      Serial.print( "Kommando bis jetzt " );
      Serial.print( cmd );
      Serial.print( "\n" );
    }
  }
}

Noch ein Tip (der im Code schon ein wenig eingearbeitet ist): Um das 
Stochern im Dunkeln zu vermeiden, was denn eigentlich der µC macht, ist 
es ab und an ganz hilfreich, wenn man sich einfach mal ein paar Dinge 
ausgeben lässt, damit man am Terminal sieht, was der µC empfangen hat 
und was er mit dem Zeichen anstellt.

Im obigen hab ich ein ';' als Trennzeichen benutzt. Kommandos werden 
also zb. in der Form

LEDon;LEDoff;

eingegeben, wobei der ';' das Ende der Eingabe markiert. Du kannst auch 
jedes andere Trennzeichen benutzen (zb einen '\n'). Aber um Probleme mit 
der Carriage_Return / Line_Feed Problematik zu vermeiden, hab ich der 
Einfachheit halber erst mal einen ';' gewählt.

[chris (Gast)]

EV 
http://awtfy.com/2011/05/23/a-minimal-arduino-library-for-processing-serial-commands/

[Jürgen S. (jurs)]

max2d schrieb:
> Also mein Programm sieht jetzt wie folgt aus:
>

> 
> if (Serial.available () > 0)
> {
> delay (25);
> 
> while (Serial.available () > 0)
> {
>    if (Serial.read)= == '13On')
>    {
>      led = true;
>    }
> }
> 
> }
>

>
> Leider tut sich nichts. Muss ich also doch noch was ändern?

Damit es einen gruselt, brauchst Du nichts ändern. Es IST GRUSELIG!

Damit es funktioniert, mußt Du mehrere Dinge ändern.

Du hast extreme Defizite, selbst für einen Anfänger mit 
C/C++-Programmierung.

Erstens hast Du nicht verstanden, wie man eine Funktion aufruft:

Wenn Du im Code schreibst "Serial.read", dann ist das die Adresse im 
RAM, wo die Funktion liegt. Wenn Du die Funktion aufrufen und ausführen 
möchtest, gehören die Parameter in Klammern dahinter, auch wenn die 
Parameterliste leer ist. Also Funktionsaufruf mit "Serial.read()".

Als nächstes sind Dir offenbar die Variablentypen und Objekte vollkommen 
unklar, mit denen Du hantierst. Eine char-Variable ist ein einzelnes 
Zeichen, und einzelne Zeichen stehen in einzelnen Hochkommas!

Was machst Du? '13On' ist kein einzelnes Zeichen.
Einzelne Zeichen wären '1' oder '3' oder 'n' oder sowas.

Strings stehen dagegen zwischen DOPPELTEN HOCHKOMMAS.
Eine Stringkonstante sieht im Quelltext daher aus wie "13On" zwischen 
doppelten Hochkommas.

Dir fehlt es an den allerkleinsten Grundlagen der Programmiersprache.

Vielleicht solltest Du mal ein Anfänger-Tutorial durcharbeiten!

Als Code für Arduino und den seriellen Monitor habe ich Dir mal das 
vorbereitet:

String cmd; // ==> ein String-Objekt, der verkackteste Datentyp überhaupt!!!

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

void loop(){
  if (Serial.available () > 0) // Es ist ein Zeichen im Puffer
  {
    delay (25); // Warten bis alle Zeichen im Puffer
    cmd="";
    while (Serial.available()> 0) // Alle Zeichen einzeln auslesen
    {
      char c=Serial.read();
      if (c>=32) cmd=cmd+c; // Nur Zeichen mit ASCII-Code >=32 
    }
    // Jetzt ist der empfangene String komplett und wird ausgewertet
    if (cmd=="ledON") Serial.println("Kommando: ledON");
    else if (cmd=="ledOFF") Serial.println("Kommando: ledOFF");
    else Serial.println("Unbekanntes Kommando");
  }
}

Wenn Du mit Zeichen und Strings arbeitest, solltest Du Dir auch ein paar 
Grundlagen über den ASCII-Code aneignen. Steuerzeichen und sichtbare 
Zeichen.

Den seriellen Monitor von Arduino kannst Du nämlich so einstellen, dass 
er nach jeder Eingabe als "Zeilenende" noch zusätzliche Steuerzeichen 
sendet, die Du nicht einzugeben brauchst, und zwar CR (Zeilenumbruch) 
oder NL (New Line) oder beides.

Mit diese Zeile in meinem Code:
      if (c>=32) cmd=cmd+c; // Nur Zeichen mit ASCII-Code >=32
werden diese Steuerzeichen am Ende herausgefiltert und nicht in den 
empfangenen String eingebaut, so dass dieser Code funktioniert, egal wie 
Du den seriellen Monitor eingestellt hast, wie er das Zeilenende senden 
soll, ob als CR, NL oder CR+NL.

Ach ja: Die Eingabe der Kommandos erfordert die Beachtung von Groß- und 
Kleinschreibung. Wenn die Kommandos auch in Abweichender 
Groß-/Kleinschreibung erkannt werden sollen, müßte man den Code etwas 
ändern.

Die Auswertung nach dem Vorschlag von Karl Heinz, mit dem eindeutigen 
ASCII-Zeichen als Befehlsende-Zeichen und ohne auf die vollständige 
Befehlsübertragung zu warten, ist für Anfänger natürlich auch möglich. 
Am besten filterst Du dann aber entweder die Steuerzeichen aus, ohne sie 
in den String aufzunehmen, oder Du konfigurierst den seriellen Monitor 
in Arduino so, dass keine Zeilenende-Zeichen gesendet werden. Sonst 
bekommst Du nämlich bei den Debugausgaben über Serial das Problem, dass 
Du die unsichtbaren Steuerzeichen nicht korrekt dargestellt bekommst.

[Alexander K. (minjaman)]

Ich benutze das hier erfolgreich:

https://github.com/scogswell/ArduinoSerialCommand

[Karl H. (kbuchegg)]

Jürgen S. schrieb:

> Die Auswertung nach dem Vorschlag von Karl Heinz, mit dem eindeutigen
> ASCII-Zeichen als Befehlsende-Zeichen und ohne auf die vollständige
> Befehlsübertragung zu warten, ist für Anfänger natürlich auch möglich.
> Am besten filterst Du dann aber entweder die Steuerzeichen aus, ohne sie
> in den String aufzunehmen,

Ich wollte es mal nicht zu kompliziert machen.
Je nachdem, wer am anderen Ende der Leitung sitzt, kann man da noch 
einiges an Aufwand investieren. Vor allen Dingen, wenn ein Mensch am 
anderen Ende der Leitung sitzt. Denn dann müssen vorlaufende und 
nachlaufende Leerzeichen, Tabulatoren ausgefiltert werden, während sie 
aber mitten im Text erhalten bleiben sollen. Und eine Behandlung von 
Backspace wär auch nicht schlecht.

Alles in allem sind das aber Grundfertigkeiten, die jeder beherrschen 
muss, egal ob er dann in einem realen Programm eine vorgefertigte 
Parsing-Komponente benutzt oder nicht. Hier geht es einfach in erster 
Linie um eine Grundtechnik. So wie jeder Mechaniker am Anfang seiner 
Ausbildung den Umgang mit Säge und Feile lernt, egal ob er später dann 
an einer CNC Maschine steht oder nicht.

[Jürgen S. (jurs)]

Karl Heinz schrieb:
> Ich wollte es mal nicht zu kompliziert machen.
> Je nachdem, wer am anderen Ende der Leitung sitzt, kann man da noch
> einiges an Aufwand investieren. Vor allen Dingen, wenn ein Mensch am
> anderen Ende der Leitung sitzt. Denn dann müssen vorlaufende und
> nachlaufende Leerzeichen, Tabulatoren ausgefiltert werden, während sie
> aber mitten im Text erhalten bleiben sollen. Und eine Behandlung von
> Backspace wär auch nicht schlecht.

Der serielle Monitor von Arduino ist kein richtiges Terminalprogramm. 
Sondern der serielle Monitor hat einen Zeileneditor, in dem man eine 
Befehlszeile vor dem Absenden manuell editieren kann wie man möchte, und 
erst beim Drücken von Return oder auf den Senden-Button wird die ganze 
eingegebene Zeile in einem Rutsch gesendet.

Daher funktioniert für Anfänger auch der oben von mir gepostete Code mit 
dem delay(25), der nach dem Empfang des ersten Zeichens etwas wartet.

Dein Code ist auch für die Verwendung mit manueller Bedienung über ein 
klassisches Terminalprogramm geeignet: Die Zeichen werden so lange 
gesammelt bis das spezielle abschließende Zeichen kommt. Egal wie lange 
es dauert.

Mit Ausfilterung von Steuerzeichen und den fehlenden Deklarationen für 
die setup() Funktion und "led" als OUTPUT gesetzt. Dein Code als 
kompletter Arduino-Sketch:

String cmd;
byte led=13;

void setup(){
  Serial.begin(9600);
  pinMode(led,OUTPUT);
}

void loop()
{
  char nextChar;
  if (Serial.available() > 0) 
  {
    nextChar = Serial.read();
    Serial.print( "Zeichen: '" );
    Serial.print( nextChar );
    Serial.print( "'\n" );

    if( nextChar == ';' ) {
      Serial.print( "Kommando vollstaendig '" );
      Serial.print( cmd );
      Serial.print( "'\n" );
      
      if( cmd == "LEDon" )
        digitalWrite(led, HIGH);
      else if( cmd == "LEDoff" )
        digitalWrite(led, LOW);
      cmd = "";
    }

    else if (nextChar>=32){
      cmd += nextChar;
      Serial.print( "Kommando bis jetzt " );
      Serial.print( cmd );
      Serial.print( "\n" );
    }
  }
}

> Alles in allem sind das aber Grundfertigkeiten

ACK.

Die Verwendung von String-Objekten, wie es der TO mit der Variablen 
"cmd" beabsichtigt, ist aber auch unter Arduino kontraproduktiv. Die 
Dinger sind voll die Pest: Es gibt eine handvoll Funktionen, die man 
damit einem Anfänger supereinfach erklären kann. Zum Beispiel ein 
Zeichen oder einen String mit dem Pluszeichen hinten dranhängen. Aber zu 
den zig Libraryfunktionen der AVR libc sind diese Stringobjekte genau so 
inkompatibel wie zu den Arduino eigenen Libraries. Da sollte er lieber 
gleich lernen, wie C-Strings in Form von char-Arrays funktionieren.

[Karl H. (kbuchegg)]

Jürgen S. schrieb:
> Karl Heinz schrieb:
>> Ich wollte es mal nicht zu kompliziert machen.
>> Je nachdem, wer am anderen Ende der Leitung sitzt, kann man da noch
>> einiges an Aufwand investieren. Vor allen Dingen, wenn ein Mensch am
>> anderen Ende der Leitung sitzt. Denn dann müssen vorlaufende und
>> nachlaufende Leerzeichen, Tabulatoren ausgefiltert werden, während sie
>> aber mitten im Text erhalten bleiben sollen. Und eine Behandlung von
>> Backspace wär auch nicht schlecht.
>
> Der serielle Monitor von Arduino ist kein richtiges Terminalprogramm.
> Sondern der serielle Monitor hat einen Zeileneditor, in dem man eine
> Befehlszeile vor dem Absenden manuell editieren kann wie man möchte, und
> erst beim Drücken von Return oder auf den Senden-Button wird die ganze
> eingegebene Zeile in einem Rutsch gesendet.

Ah. Das wusste ich nicht.
Ich dachte, das wäre ein ganz normales Terminal.

Nun denn - wenn dieser serielle Monitor das so handhabt, dann wundert es 
mich nicht mehr, dass Arduino Programme zwar mit diesem Werkzeug 
funktionieren, im realen Einsatz mit beliebigen anderen Progammen aber 
kläglich scheitern.

[Jürgen S. (jurs)]

Karl Heinz schrieb:
> Nun denn - wenn dieser serielle Monitor das so handhabt, dann wundert es
> mich nicht mehr, dass Arduino Programme zwar mit diesem Werkzeug
> funktionieren, im realen Einsatz mit beliebigen anderen Progammen aber
> kläglich scheitern.

In Arduino-Programmen funktioniert genau das, was man programmiert.

Der von mir mit Posting um 12:34 gepostete Sketch empfängt Befehle, die 
"in einem Rutsch" gesendet werden, aber mit Sendepausen dazwischen. Und 
das funktioniert auch, wenn der Befehl zum Beispiel von einem 
PC-Programm gesendet wurde, das mit Java, Visual Basic, Delphi, Wiring 
oder sonstwas programmiert wurde.

Der von mir mit Posting um 13:24 gepostete Sketch mit Deiner Logik und 
einem Semikolon als abschließendes Zeichen nach dem Befehl funktioniert 
auch bei manueller Eingabe mit Terminalprogrammen.

Allerdings ist der Sketch mit Deiner Logik anfällig für 
"Denial-of-Service" Attacken. Während mein vorher geposteter Code in 25 
Millisekunden bei 9600 Baud nur 25 Zeichen empfangen kann, womit das 
String-Objekt auf maximal 25 Zeichen Länge begrenzt wird, würde bei 
Deiner Logik ein Datenstrom ohne Semikolon dazu führen, dass immer noch 
ein und noch ein Zeichen an das String-Objekt drangehängt wird, bis der 
RAM-Speicher überläuft.

Aber das ist ja hier nicht das Thema, Fehleingaben vernünftig 
abzufangen, der TO wollte ja überhaupt nur einmal so etwas wie Befehle 
empfangen können. Und dazu hat er jetzt zwei Codes zur Auswahl.

[max2d (Gast)]

 String cmd;
 byte led=13;
 void setup(){
   Serial.begin(9600);
   pinMode(led,OUTPUT);
 }
 
 void loop()
 {
   char nextChar;
   if (Serial.available() > 0)
   {
     nextChar = Serial.read();
     Serial.print( "Zeichen: '" );
     Serial.print( nextChar );
     Serial.print( "'\n" );
 
     if( nextChar == ';' ) {
       Serial.print( "Kommando vollstaendig '" );
       Serial.print( cmd );
       Serial.print( "'\n" );
 
       if( cmd == "LEDon" )
       digitalWrite(led, HIGH);
       else if( cmd == "LEDoff" )
       digitalWrite(led, LOW);
       cmd = "";
     }
 
     else if (nextChar>=32){
       cmd += nextChar;
       Serial.print( "Kommando bis jetzt " );
       Serial.print( cmd );
       Serial.print( "\n" );
     }
   }
 }

Ich habe jetzt mal diesen Code genommen.
Funktioniert auch soweit, wenn ich im Serial Monitor das entsprechende 
Kommando setze (LEDon;).
Wenn ich jetzt aber mit meinem Programm, dass ich über Visual Studio in 
C# geschrieben habe den gleichen Befehl sende tut sich nichts!
Erst wenn ich das ; durch einen buchstaben ersetze funktioniert es. 
Warum?!

[Jürgen S. (jurs)]

max2d schrieb:
> Ich habe jetzt mal diesen Code genommen.
> Funktioniert auch soweit, wenn ich im Serial Monitor das entsprechende
> Kommando setze (LEDon;).
> Wenn ich jetzt aber mit meinem Programm, dass ich über Visual Studio in
> C# geschrieben habe den gleichen Befehl sende tut sich nichts!
> Erst wenn ich das ; durch einen buchstaben ersetze funktioniert es.

Das kann ich irgendwie nicht glauben.
Hast Du vielleicht in Deinem C#-Programm Semikolon und Doppelpunkt 
verwechselt?

Der Arduino-Sketch erzeugt jedenfalls umfangreiche Debug-Ausgaben.

Kopiere mal die Ausgabe aus dem seriellen Monitor heraus, wenn Du 
dreimal nacheinander von Deinem Programm aus den Befehl mit 
abschließendem Semikolon gesendet hast!

[Karl H. (kbuchegg)]

Jürgen S. schrieb:

> Der Arduino-Sketch erzeugt jedenfalls umfangreiche Debug-Ausgaben.

erstens das (nur müsste er die eben in seinem C# Programm auch sichtbar 
machen oder sonst irgendeine Möglichkeit haben, sich die relevanten 
Informationen anzeigen zu lassen)

zweitens kommt an dieser Stelle der Tip mit der Installation eines 
'Serial Port Monitors' auf dem PC ins Spiel, der einem Byte für Byte 
exakt anzeigt, was eigentlich über die Serielle Schnittstelle rausgeht 
bzw. rein kommt.

[Masl (Gast)]

Ich empfehle, das Programm "HTerm" zu benutzen (ja, ich weiß, ist kein 
Terminal im engen Sinne).
Da siehst du genau was auf der Leitung passiert, und kannst dir die 
Werte auch in verschiedenen Darstellungen anzeigen lassen (Hex, bin, 
ASCII, dez).

Wenn du mit diesem Tool festgestellt hast, dass dein Arduino-Programm 
stabil läuft kannst du beginnen dein C# Programm zu schreiben.

Dieses Vorgehen ist einfacher als der Versuch, zwei Programme zu 
verheiraten von denen du bei beiden nicht weißt, ob sie funktionieren.
Benutzt du erstmal HTerm oder ein anderes fertiges PC-Tool kannst du dir 
im Fehlerfall sicher sein, dass sich der Fehler im Arduino-Programm 
befindet.
=> systematisches Vorgehen

[Daniel A. (daniel-a)]

Man kann die Kommandos auch empfangen und ausführen ohne diese 
Zwischenspeichern zu müssen. Zudem könnte man die Kommandos in einer 
Liste speichern, um das Hinzufügen neuer Kommandos einfacher zu machen. 
Ich habe für alle interessierten ein kleines Beispiel geschrieben.

[Jürgen S. (jurs)]

Daniel A. schrieb:
> Man kann die Kommandos auch empfangen und ausführen ohne diese
> Zwischenspeichern zu müssen. Zudem könnte man die Kommandos in einer
> Liste speichern, um das Hinzufügen neuer Kommandos einfacher zu machen.
> Ich habe für alle interessierten ein kleines Beispiel geschrieben.

Danke für den Code, funktioniert einwandfrei!

Für Arduino-Interessierte habe ich mal kurz einen über Serial laufenden 
Arduino-Sketch draus gemacht.

[Josef N. (josine01)]

Hallo,

auch wenn der Thread schon ein paar Jahre alt ist, hat er mir sehr 
geholfen, meine eigenen Routinen für das Auslesen des Seriellen Monitors 
zu schreiben.

Nachdem hier ja echte Profis unterwegs sind, möchte ich meine Routinen 
mal online stellen und freue mich sowohl über Kritik als auch Lob.

Das Zusammenfassen der Befehle bitte ich zu entschuldigen, ist für mich 
übersichtlicher.

[Joachim B. (jar)]

Josef N. schrieb:
> Nachdem hier ja echte Profis

bin ich nicht

aber Titel Arduino

Serial.event ist die Lösung
https://www.arduino.cc/en/Tutorial/SerialEvent

mein Codeschnipsel (fehlendes ergänzen)

sonst war das ja Leichenfledderei von 2014

void inSTR_Auswertung(void)
{ if(strlen(serial_in_command))
  { Serial.println(); Serial.print(serial_in_command);  Serial.println(F(" -> erkannt")); 
    // ..... hier gehts weiter
    if( !strcmp(serial_in_command, "help") || ( !strcmp(serial_in_command, "?") && strlen(serial_in_command)==1 ) )               // 26672 Bytes
    { // help screen
      Serial.println(F("\ncommands: \n"));
         
      Serial.println(F("reset"));
      Serial.println(F(""));
    }
    else if( !strcmp(serial_in_command, "reset") )
    { // "reset"
      delay(250);
      {asm("ldi r30,0"); asm("ldi r31,0"); asm("ijmp");}
    } // if( !strcmp(serial_in_command, "reset") )
  } // if(strlen(serial_in_command))
  memset(&serial_in_command[0], 0, sizeof(serial_in_command)); 
  stringComplete = false;
} // void inSTR_Auswertung(void)


void serialEvent(void) 
{ while (Serial.available()) 
  { char incomingByte = (char)Serial.read();
    if(incomingByte == '\r')  // Wenn das Enter ankommt
    { serial_in_buff[chr_cnt] = '\0';
      strcpy(serial_in_command, serial_in_buff);
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
      chr_cnt = 0;
      stringComplete = true;
    }
    else // Falls kein Enter kommt muss der Text gespeichert werden in dem inText Array
    { if(isprint(incomingByte))
      { if(chr_cnt<(MAXBUFFER-2))
          serial_in_buff[chr_cnt++] = incomingByte;
        else
        { Serial.println(F("serBUF ov-> DEL"));
          *serial_in_command=0;
          chr_cnt=0;
        } // if(chr_cnt<(MAXBUFFER-2))
      } // if(isprint(incomingByte))
    } // if !(incomingByte == '\r')
  } // while (Serial.available()) 
} // void serialEvent()

[Josef N. (josine01)]

Hallo,

vielen Dank für die Antwort.

Das Tutorial zu Serial.Event habe ich verstanden, allerdings tut es im 
wesentlichen ja auch nichts anderes als mein Code, fragt lediglich 
zusätzlich auf Zeilenende ab. Mir war der Ansatz wichtig, die Abfrage in 
Subs zu lösen und nicht im Hauptprogramm.

Deinen Code habe ich nicht verstanden, der ist mir viel zu komplex. Ich 
vermute, Du baust auf irgendwelchen Objekten auf. Nachdem mein einfacher 
Code aber auch funktioniert, würd ich mir diese mühsame Einarbeitung 
sparen, aber vielen Dank trotzdem.

[Joachim B. (jar)]

Josef N. schrieb:
> vielen Dank für die Antwort.

kein Problem aber da bei dir überall

do {} while (Serial.available() <1); char nextChar;

steht was umständlich und überflüssig ist,

hatte ich auch mal, nutze doch einfach Serial.event

Das läuft im Interrupt nur wenn ein Zeichen eintrudelt!

Mein Code ist eine Mischung aus C und Arduino, weil ich das mit der 
Arduino Stringklasse noch nicht verstanden habe.

Ich definiere einen Buffer

char serial_in_command[MAXBUFFER]={0};
char serial_in_buff[MAXBUFFER]={0};
char s_out_str[MAX_S_OUT_BUFF]={0};
unsigned char chr_cnt=0;

lese solange Serial.event aufgerufen wird, sammele Zeichen in 
serial_in_buff ein bis zum Enter,
kopiere die in serial_in_command[MAXBUFFER]

und springe zur Auswertung

void inSTRauswertung(void)
{
//Serial.print(F("0_____")); Serial.println(serial_in_command);                  
  if( !strcmp(serial_in_command, "help") || ( !strcmp(serial_in_command, "?") && strlen(serial_in_command)==1 ) )
  { // help screen
    Serial.println(F("\ncommands: \n"));

    Serial.println(F("hell, hellp, hellm, hellxx(0-10)"));
    Serial.println(F("conmin(50-60)"));
    Serial.println(F("conmax(75-80)"));
    Serial.println(F("con, conp, conm, conxx(55-75)"));
    Serial.println(F("date, dateJJJJ/MO/TA"));
    Serial.println(F("time, timeHH:MM:SS"));
        
    Serial.println(F("up, up?, up07:30"));
    Serial.println(F("down"));
          
    Serial.println(F("stat"));
    Serial.println(F("fstat"));
    Serial.println(F("i2ceep"));
        
    Serial.println(F("reset"));
    Serial.println();
//    memset(&serial_in_command[0], 0, sizeof(serial_in_command));
  }

// hier kommen nun soviel else if wie es Menüpunkte gibt

  else if( strstr(serial_in_command, "hell") )
  { // hell9
    if( strlen(serial_in_command)==4 || (strlen(serial_in_command)==5 && strstr(serial_in_command, "?") ) ) 
    { Serial.print(F("hell= ")); Serial.print(MY_EEP_VAR.backlicht); Serial.println(); }
    else if( !strcmp(serial_in_command, "hellp") )
      backlight_p();
    else if( !strcmp(serial_in_command, "hellm") )
      backlight_m();
    else if( !strncmp(serial_in_command, "hell", 4) && strlen(serial_in_command)>4 && strlen(serial_in_command)<7 )
    { // "hell??"
      uint8_t tmp_hell = atoi( (char *)serial_in_command + 4);
      if( tmp_hell>=MIN_BL && tmp_hell<=MAX_BL )
      {  MY_EEP_VAR.backlicht = tmp_hell;
         analogWrite(NOK_BL, pgm_read_byte(&pwmtable_11C[MY_EEP_VAR.backlicht])); 
         con_hell_stat(true);  
      }
      else
      { sprintf_P(s_out_str, PSTR("hellxx (%d)-(%d)"), MIN_BL, MAX_BL); Serial.println(s_out_str); } 
    } // if( !strcmp(serial_in_command, "hell??") )
  } // if( strstr(serial_in_command, "hell") )

  #include "c-source\eif_con.c"      
  #include "c-source\eif_date.c"      
  #include "c-source\eif_time.c"      
  #include "c-source\eif_up.c"      
  #include "c-source\eif_down.c"      
  #include "c-source\eif_auto.c"      
  #include "c-source\eif_reset.c"      

// wenn alles erledigt ist loesche serial_in_command
  *serial_in_command=0;
  // memset(&serial_in_command[0], 0, sizeof(serial_in_command));
} // void inSTRauswertung(void)

[Josef N. (josine01)]

Joachim B. schrieb
> kein Problem aber da bei dir überall
> do {} while (Serial.available() <1); char nextChar;
> steht was umständlich und überflüssig ist,
> hatte ich auch mal, nutze doch einfach Serial.event
> Das läuft im Interrupt nur wenn ein Zeichen eintrudelt!

Vielen Dank, jetzt hab ich's begriffen und die Interrupt-Lösung ist 
natürlich schon wesentlich eleganter.

Dein Code wird mir inzwischen auch etwas klarer, ist halt ein universell 
einsetzbarer Code, der vorallem Sinn macht für störbehaftete 
Übertragungen. Werd ich später mal genauer anschauen, aber ich brauch 
den seriellen Monitor derzeit nur zum Debugging meiner Alarmanlage, um 
zu schauen, wann die Infrarot- und Radarsensoren auslösen, weil ich 
derzeit noch zu viel Fehlalarme habe. Und die Routinen waren eigentlich 
nur dazu gedacht, die jeweils aktuelle Uhrzeit beim Hochladen des 
Sketches etwas eleganter einzugeben als jeweils im Code die 
Uhrzeitvariablen manuell zu setzen.

Vielen Dank nochmal für Deine Mühe, wenns Dich interessiert, meine 
Alarmanlage ist auf

https://youtu.be/KvP90prt6rM zu sehen.