Arduino Rs232

[Sven (Gast)]

Hallo
Ich möchte zwei int Variablen von einem Avr zum anderen Übertragen 
mittels Seriell.
Dafür verwende ich wie im Beispiel die Magie von parseInt();

  while (Serial.available() > 0) {
    int m1t = Serial.parseInt();
    int m2t = Serial.parseInt();     
      if (Serial.read() == '\n') {

Wenn ich die Daten vom Pc generieren lasse scheint es wunderbar zu 
klappen.
Wenn ich die Daten aber vom 2. Avr sende habe ich Aussetzer. So Das der 
Empfänger teilweise sekundenlang nix mehr empfangen möchte.
Die Daten mit Hterm mitgelesen sehen aber absolut korrekt aus.
Der Empfänger arbeitet auch weiter meint nur keine Daten mehr zu 
bekommen. Und ohne Neustart geht es dann auf einmal auch wieder.

Woran könnte das liegen?
Wie funktioniert ParseInt?
Was macht der wenn der zb mal ein Byte falsch übertragen wird? wartet er 
dann auf ein Byte ? Bekommt vom Sender aber gleich wieder ganz viele und 
ist dann vielleicht um ein Byte aus der Spur?

[Mick (Gast)]

Hast du gemeinsames GND zwischen beiden Mikrocontrollern? Evtl. serielle 
Widerstände bei RX/TX Lines verwenden.

[Sven (Gast)]

Mick schrieb:
> Hast du gemeinsames GND zwischen beiden Mikrocontrollern? Evtl.
> serielle
> Widerstände bei RX/TX Lines verwenden.

Jap gemeinsame Versorgung incl Masse und Extra noch einige Kondensatoren 
in der Versorgung.
Widerstände habe ich keine drin. Nein mittlerweile kann ich sogar 
Bestätigen das das Problem vom Parseint kommt.
Es wartet tatsächlich auf ein Byte. Wenn aber Zwei kommen Wartet es 
wieder auf eins. bis mal wieder nur eins kommt. Also bis zum nächsten 
Fehler.
Das ist reichlich ungut.

[Mick (Gast)]

Ok, schau mal hier: https://www.arduino.cc/en/Reference/parseInt
parseInt gibt schon beim ersten empfangenen Byte einen Wert zurück, 
sofern dieses eine Zahl ist.

Vielleicht hilft dir das hier weiter: 
https://www.arduino.cc/en/Tutorial/StringToIntExample

[Sven (Gast)]

Ich befürchte ich brauche da einen neuen Ansatz.
Also ich möchte zwei int zahlen(-255-+255) oder 4 Byte (0-255)
übertragen. Allerdings Permanent und Schnell.
Und irgendwie muss auch Sichergestellt werden das die Bytes nicht 
verschoben ankommen.
Bietet Arduino da schon andere Lösungen?
In Bascom hätte ich mir ein Fifo Buffer gebaut und Byte für Byte 
ausgelesen bis ein Bestimmtes Byte kommt und dann alle X Byte davor 
passend einsortiert und dann noch mit einer Checksumme verglichen.
Bascom kann ich gerade nicht verwenden weil ich gerade kein Windows zur 
Hand habe.

[nicht“Gast“ (Gast)]

Was hindert dich daran, das mit C++ ebenso zu machen?
Auch kannst du bascom auf deinen Arduino drauf machen.

Grüße

[Joachim B. (jar)]

Serial.read hat doch FiFo

warum schickst du nicht einfach ASCII mit CR?

#define MAXBUFFER 20
char serial_in_command[MAXBUFFER]={0};
char serial_in_buff[MAXBUFFER]={0};
unsigned char chr_cnt=0;

  // --------------- serial in ---------------
  if(Serial.available() > 0) 
  { char incomingByte = (char)Serial.read();
    if(!(incomingByte == 13))  // Falls kein Enter kommt muss der Text gespeichert werden in dem inText Array
    { if( isprint(incomingByte) )
        if(incomingByte=='-' || incomingByte=='+' || isdigit(incomingByte) ) // Ergänzung nur für Zahlen
          serial_in_buff[chr_cnt++] = incomingByte;
    }
    else // Wenn das Enter ankommt
    { strcpy(serial_in_command, serial_in_buff);
      chr_cnt = 0;
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
    }
  } // if (Serial.available() > 0) 
  
  if(strlen(serial_in_command))
  {   
    // fuer dich
    int16_t int_var = atoi(serial_in_command);

/*
    Serial.println(); Serial.print(serial_in_command); Serial.println(F("->erkannt"));
    if( strstr(serial_in_command, "help") || ( strstr(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("con, conp, conm, conxx -> 65-75"));
      Serial.println(F("date, dateJJJJ/MO/TA"));
      Serial.println(F("time, timeHH:MM:SS"));
      Serial.println(F("temp"));
      Serial.println(F("reset"));
      Serial.println(F(""));
      *serial_in_command=0;
    } // if( strstr(serial_in_command, "help") || ( strstr(serial_in_command, "?") && strlen(serial_in_command)==1 ) )

    else if( strstr(serial_in_command, "hell") )
    { if( !strcmp(serial_in_command, "hellp") )
*/

    *serial_in_command=0; // oder
//    memset(&serial_in_command[0], 0, sizeof(serial_in_command)); // oder
//    memset(serial_in_command, 0, sizeof(serial_in_command));
  } // if(strlen(serial_in_command))

[Mick (Gast)]

Ich verwende vielfach die EasyTransfer Bibliothek: 
https://github.com/madsci1016/Arduino-EasyTransfer

Die ist wirklich der Hammer. Damit kannst du ganze struct Blöcke 
übertragen. Der Transfer wird zusätzlich mittels Checksummen geprüft.