ARM: Doppeltes Verschicken von Bytes mit UART

[Robert S. (r0b)]

Hallo zusammen!


Ich habe ein Problem beim Senden mit UART0. Im Durchschnitt wird jedes 
500. Byte fälschlicherweise doppelt verschickt, wobei der Fehler 
unregelmäßig auftritt. Bin mir jetzt nicht sicher ob es am Code(wobei 
man da wohl nicht sooo viel falsch machen kann) oder an der Hardware 
liegt. Ich hab von Olimex ein LPC-H2103 Board.
Die Uart Einstellungen muessten passen. Aber auch wenn nicht werden 
Bytes eher wohl gar nicht verschickt anstatt doppelt.
Für weitere Anregungen für die Fehlerursache wäre ich Euch sehr dankbar.


An die Funktion uart_sendPose wird ein float Array mit 6 Werten 
übergeben.

void uart_sendPose(float *fPose)
{
  int8_t j,i;
  
    
  for(j = 0; j < 6; j++)
  {
    for(i = 3; i >= 0; i--)
    {  
      uart_putc(*(((char *)fPose)+j*4+i));
    }
  }
         uart_putc(13);
  uart_putc(10);
}

void uart_putc(uint8_t c)
{
  while (!(U0LSR & (1 << 5)))
  continue;
  U0THR = c;  
  
}

Gruß Robert

[Robert S. (r0b)]

Meine Baud-rate weicht um ca. 0,20% von der gewünschten (38400) ab, 
weils mit meinem Quarz nicht anderst geht. Das kann nicht der Fehler für 
das Doppeltschicken sein?

[Gast (Gast)]

Bis zu 1% ist das unkritisch.

[Harald (Gast)]

Wie stellst Du fest, dass jedes x. Byte doppelt versendet wird?

Falls es ein PC mit einem USB-to-Serial Wandler ist, würde ich erstmal 
diesen Wandler als Fehlermöglichkeit mit einbeziehen. Man könnte im 
Device-Manager einiges an den Puffergrößen drehen oder aber einen 
anderen Chipsatz austesten.

[Robert S. (r0b)]

Danke Harald,

das werd ich gleich morgen ma checken.


Gruß Robert

[Robert S. (r0b)]

an einem Wandler kann das problem auch nicht liegen. Wenn ich in meinem 
Programm an der Stelle wo sonst geschickt wird, ein definiertes Array 
verschick, kommt das "Doppeltschicken" nicht vor.

Kann es sein, dass der µC bei dieser Programmzeile beim casten oder beim 
Adressensprung ab und zu nen Fehler macht?

uart_putc(*(((char *)fPose)+j*4+i));

Gruß Robert

[Ahem (Gast)]

Wie gross ist denn bei Dir ein float?
Auffällig ist, das Du mit j, so wie es in den Ausdruck eingebaut hast 
Adressrechnung auf char-Ebene machst und nicht auf den Elementen eines 
float-Arrays.

[Ahem (Gast)]

Ach nein. Du multiplizierst ja mit 4. OK. Hmmm.

[Robert S. (r0b)]

mein array hat 6 floats, ein float hat 4 bytes. geschickt wird 
byte-weise deswegen cast ich auf char. die innere schleife läuft von 3 
bis 0 also verkehrtrum wegen der Big Endian codierung.

Das schicken funktioniert ja im prinzip, nur eben öfers fehlerhaft weil 
bytes doppeltgeschickt werden. Für meine anwendung is der fehler aber zu 
hoch, da ich dann immer neu synchronisieren muss.


Hab nun mal ein neues Projekt angelegt. dabei verschick ich jedes ma 256 
bytes.

while (1)
  {
        for(i=0;i<256;i++)
          uart_putc(i);
  }

Dort verschickt er IMMER die 19(hex) doppelt. Baudrate hab ich scho 
verkleinert, bringt nix...

Ich verzweifel langsam.

Gruß Robert

[Ahem (Gast)]

Moment mal, Du meinst, der folgende_ Code schickt das Byte 0x19 _immer 
doppelt? Sowas habe ich ja noch nie gehört.

while (1)
  {
        for(i=0;i<256;i++)
          uart_putc(i);
  }

Schicke mal den kompletten kompilierbaren Code von dem Beispiel das ich 
jetzt hier auch zitiert habe.

Was benutzt Du für ein Terminalprogramm? Welche Terminalemulation? 
Welches OS? Irgendwelche USB-Serial-Wandler dazwischen?

[Ahem (Gast)]

Ich hoffe das ist kein Aprilscherz.

[Ahem (Gast)]

Was passiert wenn Du einfach nur die 0x19 schickst?

while (1)
  {
      uart_putc(0x19);
  }

[Ahem (Gast)]

Ach, das ist auch blöd. Aber schicke einfach mal 0x19 gefolgt von irgend 
einem anderen Zeichen.

while (1)
  {
      uart_putc(0x19);
      uart_putc(0xA5);
  }

[Robert S. (r0b)]

Ich benutze Hyperterminal. Emulation hab ich mit automatischer erkennung 
und ansi probiert.
wenn ich nur

while (1)
  {
      uart_putc(0x19);
      uart_putc(0xA5);
  }

verschick, dann wird die 19 nicht doppelt verschickt. verschick ich ne 
liste von uart_putc(0) - uart_putc(128) dann wird die 19 doppelt 
verschickt. es ist auch definitiv nicht das 19(hex) byte was doppelt 
verschickt wird sondern der wert 0x19.
Zudem teste ich immer mit hypertermial auf nem pc und mit einem Laptop.

Und nein es ist kein Aprilscherz :-)


Gruß Robert

[holger (Gast)]

>es ist auch definitiv nicht das 19(hex) byte was doppelt
>verschickt wird sondern der wert 0x19

Na watt denn nun? Gib den Wert mal dezimal an.

[... .. (docean)]

hmm was passiert wenn du 0x18 und dann 0x19 und 0x1a verschickst?

Probier mal hterm, putty oder ander aus...

Vlt. werden die als steuerzeichen 
interpretiert...http://de.wikipedia.org/wiki/Steuerzeichen

Oder guck mal dem KO nach ob wirklich zweimal versendet wird

[HyperHyper (Gast)]

So ist das mit dem Hyperterminal nun. Ich habe es schon mehrmals 
versucht, andere auch schon, aber ab und zu läuft es einfach nicht und 
keiner weiss warum. Versuch mal putty oder, wenn vorhanden, verbinde 
beide UARTS und bau dir ein loopback und zähl die Zeichen.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

0x19 ist CTRL-Y, und in Windoof ist das bei manchen Programmen die 
Funktion "Wiederholen"...

BTW:
Mein Terminalprogramm ist OCconsole, das zeigt nur an,
was wirklich da ist und läuft ohne Installation vom USB-Stick.

[Robert S. (r0b)]

so, hab den übeltäter!

es liegt an der 0x18. jedes zeichen nach der 0x18 wird im hyperterminal 
doppelt aufgezeichnet. 0x18 ist als Steuerzeichen "cancel". Mit Putty 
funktionierts, da zeigt es mir die zeichen nach 0x18 nur einma an.


Gruß Robert

[... .. (docean)]

sag ich doch... :D

schön das es jetzt tut...

[Robert S. (r0b)]

jap, danke dir docean ;)