Teile aus Datenstrom von RS232 entnehmen

Hallo Leute, ich würde gerne an meinen Arduino per RS232 Daten senden und dann teile des Datenstromes verwenden.

zb. sende ich.: A / 04 / F1 / 255 A Bedeutet das ein anderer µC aktiviert wird über SPI (es gibt a-z also mehrere) 04 sagt dem anderen µC via SPI welchen IO er auf High Setzen soll F1 Gibt an welcher DAC aktiv sein soll 255 ist der Wert für den DAC

jetzt geht es mir darum wie ich die einzelne Daten aus dem RS232 Puffer isoliere?

Viele Grüße

Hoi, lies die Daten doch einfach als String ein und zerleg ihn in die Teile die Du brauchst. Dabei suchst Du z.B. nach dem "/" und liest VOR jedem "/" die entsprechende Anzahl Textstellen ein und ordnest sie den Variablen zu.

Hallo Klingt nach einer guten Lösung!

Nur wie mache ich das? Es wäre natürlich perfekt wenn ich direkt Sachen aus dem Datenstrom Variablen zuweisen könnte! XD

Grüße

Kannst du. Mit Serial.read() liest du immer ein Byte ein (und alle deine Werte passen in ein Byte). Das kannst du dann beliebigen Variablen zuweisen. Da musst du aber hoffen, dass es nie zu Störungen kommt und nie mehr oder weniger gesendet wird. Oder ein Zeichen als Abschluss senden das sonst nicht vorkommen.

Wenn du einen C-String hast kann man diese Funktion benutzten um ihn zu zerlegen: http://www.cplusplus.com/reference/cstring/strtok/ Und dann atoi() um den Teil-String in integer zu wandeln: http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html#ga3a1fe00c1327bbabc76688a7a1d73370

Es wurden auch schon komplexere Einlese-Routinen von Leuten hier geschrieben, die Trennzeichen und Terminierung schon berücksichtigen. Viellicht postet jemand noch was fertiges.

Oder ein Zeichen als Abschluss senden das sonst nicht vorkommen.

So mache ich das (meistens #) ebenfalls, weil wie Serenifly schon schrieb

Da musst du aber hoffen, dass es nie zu Störungen kommt und nie mehr oder weniger gesendet wird.

denn auch wenn z.B. Werte zwischen 1 und 2 stellig wechseln können kann es auch da zu Probs kommen.

Hallo Leute, Danke für die tollen Antworten, jetzt habe ich noch das Problem das meine Gesendeten Daten aus mehr wie 8Bit bestehen. Da ein ASCI Zeichen ja schon 8Bit hat. Kann ich die nicht nach und nach in eine Variable einlesen und dann Zerlegen?

Oder wird es das einfachste sein mit einer Switch case Anweisung alles abzufragen?

Grüße

Kann ich die nicht nach und nach in eine Variable einlesen und dann Zerlegen?

Das hatten wir ja bereits 2 mal vorgeschlagen. Grüße Uwe

Gibt es Dazu Infos?

Die zwei geposteten Links helfen mir nicht wircklich :blush:

Grüße

Du willst es Dir scheinbar (zu ) einfach machen. Das bringt auf lange Sicht nichts, da Du die Thematik im Detail ohnehin vollumfänglich verstehen musst, wenn Probleme auftauchen.

Ich empfehle Dir mal in den Beiträgen von jurs zu suchen.

Er hat auf diesem Gebiet in diesem Forum wirklich schon Großes geleistet.

Gruß Chris

Hallo,

unter "jurs" find ich nichts....

ich hatte jetzt die Überlegung das ich per serial.read die Daten einem Array zuordne und dann mit Index Nummern mir die passenden stellen entnehme. So wie ich das verstanden habe wird ja immer nur ein ASCI Zeichen versendet. Wenn ich also sagen wir 12 Zeichen schnell hintereinander verschicke kann ich die auf einmal ins Array Laden? Muss ich nicht vorher noch sagen, hey RS232 Puffer mit 12 Byte und die lade ich dann ins Array?

Falls das geht, wie kann ich per Index Nummer dann die Daten aus dem Array Ziehen?

Grüße

Idee habe ich von: http://forum.arduino.cc/index.php/topic,30042.0.html

per Index Nummer dann die Daten aus dem Array Ziehen?

Das geht z.B. in der Art wie Serial.print(Arrayname[index]);

Lies doch vieleicht erst mal diesen Thread mit: http://forum.arduino.cc//index.php?topic=193089.msg1426916#msg1426916

Da gib es auch ein kleines Beispiel von Schachmann, wie du den seriellen Puffer auslesen kannst. Der Puffer ist sowieso da und fasst gesamt 89 (bitte korrigieren wenn falsch - die viele Sonne hier immer voll auf's Hirn ... :grin:) Zeichen. D.h., wenn etwas via seriell gesendet wird, landet es automatisch im Puffer - du musst diesen dann einfach nur byte-weise mit Serial.read auslesen bis Puffer leer.

Du kannst dann in einer while-Schleife Serial.available abfragen (true, wenn >= 1 Zeichen vorhanden) und mit anschlieden if's oder switch case die einzelnen Zeichen prüfen, was es ist. Z.B. ob es ein für dich gültiger Wert von irgendwas ist, ein spezielles Trennzeichen was zu ignorieren wäre, bishin zum CR/LF als Zeilen-/Befehlssequenz-Ende.

Die für dich zwischenzeitlich herausgesammelten Werte kannst du dir dann in Variablen speichern. Eigentlich ganz einfach .....

Masterboy: Da ein ASCI Zeichen ja schon 8Bit hat. Kann ich die nicht nach und nach in eine Variable einlesen und dann Zerlegen?

Habe ich ja hingeschrieben. Erst die einzelnen Zeichen in ein char-Array einlesen, das Array Null-terminieren und dann mit Funktionen wie atoi oder atol in Integer umwandeln.

Das ist alles in der AVR Standard Lib: http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html

Wenn man nur 2 oder 3 Zeichen hat, kann man die Umwandlung auch einfach per Hand machen.

Es gibt wie gesagt mehrere Möglichkeiten das zu machen. Am besten du nimmst Code der von anderen schon getestet wurde anstatt selbst was zu entwickeln. Jedenfalls was das Auslesen an sich betrifft, da man die viele Fehler machen kann. Die Umwandlung ist trivialer.

Hallo, also ich habe jetzt das hier versucht nach zu basteln :-D

http://arduino.cc/en/Tutorial/ReadASCIIString

Nur funkt es nicht... Aber habe ich das richtig verstanden.:

Serieller Daten Strom.: 240,125

manuell = Serial3.parseInt(); pc_steuerung = Serial3.parseInt();

jetzt hat die variable "manuell" den Wert 240 und pc_steuerung den Wert 125?

weil Leider Funktioniert das nicht :-(

Das ganze Läuft in einer While

   Serial.begin(9600); 

    manuell = Serial3.read();

    if (Serial3.available() > 0) {
    
    
    manuell = Serial3.parseInt();
    
    pc_steuerung = Serial3.parseInt();

    valve_device_number  = Serial3.parseInt();
    
    valvenumber = Serial3.parseInt();

    aus = Serial3.parseInt();
    
    flow_1 = Serial3.parseInt();
        
    flow_2 = Serial3.parseInt();
  
    
    if ( pc_steuerung == 4)
    {
       
       if( aus == 3)                                                                                                                        // schaltet das oder die Ventile an.
          {
           
            ValveopenLCD();
            nowtimeSD();
            VaveopenSD();
            SPI_openValve(valve_device_number, valvenumber);
           
          } 
      if ( aus == 7)                                                                                                                        // schaltet die Ventile aus
      
          {
            
           ValveclosedLCD();
           nowtimeSD();
           VaveclosedSD();
           SPI_closeValve(valve_device_number, valvenumber);            
          }
      
      Wire.beginTransmission(PCF8591_A); // wake up PCF8591                                                         
      Wire.write(0x40); // control byte - turn on DAC (binary 1000000)
      Wire.write(flow_1); // value to send to DAC
      Wire.endTransmission(); // end tranmission 
      delay(5);  
      Wire.beginTransmission(PCF8591_B); // wake up PCF8591
      Wire.write(0x40); // control byte - turn on DAC (binary 1000000)
      Wire.write(flow_2); // value to send to DAC
      Wire.endTransmission(); // end tranmission      
      
    }

    switch (manuell) {                          
      
    case 'm':
.......

Mit was für einem Arduino bastelst du denn da grade ? Uno, Mega, Leonardo, Nano, .... ?

Mit Serial.begin(9600) initialisierst du den 1. Sellerie-Kopf. .... und dann liest du von Serial3 ? Nimm da mal die 3 jeweils weg.

Muss ja min. MEGA sein, oder hat der UNO auch TX3/RX3 ?

Danke, guter einwand!! Ich möchte aber 3 benutzen ;-) Programmiert wird auf dem Mega2560.

aber würde sonst der Code gehen?

MFG

Kleiner Nachtrag, es geht trotzdem nicht.... Wo kann der fehler liegen?

Grüße

Versuch doch man die serial3 zu initialisieren.

Also: Serial3.begin(speed)

Nachzulesen hier: http://arduino.cc/en/Serial/Begin

Gruss, Jürgen

Hallo,

das mache ich doch mit Serial3.begin(9600);

Also habe mich jetzt noch mal bezüglich des Serial.parseInt(); belesen und es müsste eigentlich gehen. MIt dem Befehl weist man einer Variablen jeweils den nächsten Gültigen Zahlen Wert zu.

Aber jetzt fällt mir gerade ein das ich auch Buchstaben verschicken möchte!!! HILFE....

Grüße