Empfange nur Kauderwelsch am UART (Computer)

[Konstantin L. (konze)]

Hallo zusammen,

ich versuche gerade mich ein wenig mit dem UART bzw. USART vertraut zu 
machen. Ich habe ein paar Beispiele im Internet gesucht und konnte diese 
auch nachvollziehen und habe mich dann dazu zu entschlossen die Theorie 
in die Praxis zu übertragen.
Hier kommt mein Programmcode:
main.c

/* main.c */

#include <avr/io.h>
#include <avr/delay.h>
#include "uart.h"

#ifndef F_CPU
#define F_CPU 8000000UL
#endif


int main(void) {

  uart_init();

  unsigned char i = 0;

  while(1) {
    for(i = 0; i < 128; i++) {

      uart_putc((uint8_t)i);

      _delay_ms(1);

    }
  }

  return 0;
}

uart.h

/* uart.h */

#ifndef UART_H
#define UART_H

#include <avr/io.h>

extern void uart_init (void);

static inline int uart_putc (const uint8_t c) {

  /* wait until UDR is ready for new value */
  while (!(UCSRA & (1 << UDRE)));

  /* write UDR starts transmission */
  UDR = c;

  return 1;
}

static inline uint8_t uart_getc_wait (void) {

  /* wait until something was received */
  while (!(UCSRA & (1 << RXC)));

  /* return received char */
  return UDR;
}

static inline int uart_getc_nowait (void) {

  /* return received char or -1 */
  return (UCSRA & (1 << RXC)) ? (int) UDR : -1;
}

#endif /* UART_H  */

uart.c

/* uart.c */

#include "uart.h"

#define BAUDRATE 19200UL
#define UBRR_BAUD   ((F_CPU/(16UL*BAUDRATE))-1)

void uart_init (void) {

  UBRRH = (uint8_t) (UBRR_BAUD>>8);
  UBRRL = (uint8_t) (UBRR_BAUD & 0x0ff);

  /* turn on UART receiver and transmitter */
  /* data mode 8N1, asynchronous */
  UCSRB = (1 << RXEN) | (1 << TXEN);
  UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);

  /* flush receiver register (remove invalid values) */
  do
  {
    UDR;
  }
  while (UCSRA & (1 << RXC));
}

Zum Einsatz kommt bei mir ein ATmega8L auf einem STK500 (wobei ich einen 
AVR ISP MK II als Programmiergerät einsetze da ich nur einen 
USB-zu-Seriell Adapter habe). Der ATmega8 erhält seinen Takt von einem 
externen 8MHz Quarz (entsprechende Fuses: Low: 0xFD, High: D9). Als 
USB-zu-Seriell Adapter verwende ich einen Keyspan USA-19HS.
Wie man im Programm sehen kann werden alle ASCII-Zeichen hintereinander 
über den UART übertragen. Der UART Modus ist 19200 Baud 8N1.
Leider empfange ich am Computer nur Kauderwelsch, siehe Foto:
https://dl.dropboxusercontent.com/u/6454333/mikrocontoller.net/uart_rcv01.png

Ich habe auch noch eine Messung mit meinem Logic Sniffer durchgeführt:
https://dl.dropboxusercontent.com/u/6454333/mikrocontoller.net/uart_measure01.png

In der Messung kann man sehen, dass die 117 (u), 118 (v), 119 (w) usw. 
übertragen werden.
Ich bin mit meinem Latein am Ende, was läuft hier falsch?

Vielen Dank und viele Grüße

konze

[Peter II (Gast)]

wenn du in der main

#ifndef F_CPU
#define F_CPU 8000000UL
#endif

schreibst, woher soll dann die uart.c die F_CPU kennen?

[Konstantin L. (konze)]

Wenn ich '#define F_CPU 8000000UL'  in die uart.c verlege ändert sich 
nichts. Im Makefile ist die Taktrate auch nochmal angegeben.

[Sepp (Gast)]

Hallo!

Wahrscheinlich ein Baudraten Fehler.
Wenn Du dir die Länge der Bits im Logic Sniffer ansiehst, sind diese 
dann 52µs? Ich kann das nur schlecht erkennen auf deinem Plot.
Wenn ja, dann ist das Problem am PC!

[Karl H. (kbuchegg)]

Konstantin Lübeck schrieb:
> ändert sich
> nichts. Im Makefile ist die Taktrate auch nochmal angegeben.


Dann schmeiss sie überall anders raus.
Wenn du dieselbe Angabe mehrfach im System hast, dann bringt dir das im 
besten Fall nichts. Im schlechtesten Fall stimmen die einzelnen Angaben 
nicht überein und du suchst dir einen Wolf.

[Sepp (Gast)]

Natürlich nicht vergessen:

Wie genau ist Dein Takt? Wenns ein Quarz ist, ist die Genauigkeit es 
vermutlich OK.

[Sepp (Gast)]

Ich sehe HIER jetzt kein Problem mit:

>#ifndef F_CPU
>#define F_CPU 8000000UL
>#endif

Solange F_CPU im makefile angegeben ist, passiert hier ja nichts. 
Außerdem hat er ja eh einen 8Mhz Quarz.

Prinzipiell kann man sicher aber überlegen, ob man es so machen will.

[Karl H. (kbuchegg)]

> Wie man im Programm sehen kann werden alle ASCII-Zeichen hintereinander

Um nachprüfbare Ergebnisse zu erhalten, sende erst mal nur immer 
dasselbe Zeichen. Dann kann man auch mal mit dem Oskar messen bzw. 
gewinnt ev. aus dem was am PC ankommt eine gewisse Idee, was falsch sein 
könnte.

int main(void) {

  uart_init();

  while(1) {
    uart_putc( 'x' );
    _delay_ms(10);
  }

  return 0;
}

[Karl H. (kbuchegg)]

Sepp schrieb:
> Ich sehe HIER jetzt kein Problem mit:

Wir sehen massenhaft Probleme mit dieser Form hier im Forum.

>>#ifndef F_CPU
>>#define F_CPU 8000000UL
>>#endif
>
> Solange F_CPU im makefile angegeben ist, passiert hier ja nichts.

WENN F_CPU im makefile angegeben ist.
Und wenn nicht?
Dann wird hier stillschweigend eine Taktfrequenz angenommen.

Im nächsten C-File steht

#ifndef F_CPU
#define F_CPU 4000000UL
#endif

Solange er im makefile diese ganzen #ifndef durch eine eigene Angabe mit 
zb 16Mhz ausser Kraft setzt, funktioniert alles wie gewollt. Aber wehe 
er vergisst auf die Angabe im makefile. Dann gibt es keine Fehlermeldung 
und diverse Programmteile (zb Delays, UART, LCD, ...) rechnen im 
schlimmsten Fall mit ihren jeweiligen Privatwerten für F_CPU, die nicht 
übereinstimmen müssen.

Es ist besser, wenn eine im makefile fehlende F_CPU Angabe einen Fehler 
verursacht, als wie wenn sich der Compiler anhand diverser 'Altlasten' 
aus kopiertem Code irgendwelche F_CPU Angaben aus den Fingern saugt.
Dafür zu sorgen, dass im Falle eines Programmiererversäumnisses es zu 
einer Fehlermeldung kommt, ist durchaus eine Form des defensiven 
Programmierens.

[Karl H. (kbuchegg)]

Karl Heinz Buchegger schrieb:

> gewinnt ev. aus dem was am PC ankommt eine gewisse Idee, was falsch sein
> könnte.

Es hat mit Sicherheit was mit dem Timing (sprich tatsächliche 
Taktfrequenz zu F_CPU Angaben, bzw. Einstellung auf dem PC) zu tun.
Der Serial/USB Wandler da drinnen ist dann momentan auch nur eine 
potentielle Fehlerquelle mehr.

[Karl H. (kbuchegg)]

arbeite mal die
AVR Checkliste
durch. Punkt 3.2

[Konstantin L. (konze)]

Vielen Dank für eure Unterstützung, ich denke ich habe den Fehler 
gefunden. Aber ich weiß noch nicht wie ich diesen Beheben kann.

***Derzeitiges Setup:***
Ich habe ein paar Veränderungen an meinem Programm gemacht, sodass ich 
die Übertragung von Hand auslösen kann und dass immer das gleiche 
Zeichen übertragen wird. Zudem habe ich aus allen Dateien #define F_CPU 
entfernt, da diese schon im Makefile gesetzt wird. Mein Programm sieht 
nun wie folgt aus:

main.c

/* main.c */

#include <avr/io.h>
#include "uart.h"

int main(void) {

  uart_init();

  /* PB0 as input with pullup */
  DDRB = ~0x01;
  PORTB = 0x01;

  /* PC0-5 as output, all off*/
  DDRC = 0xff;
  PORTC = ~0x00;

  while(1) {

    /* PB0 high: transmit once and turn on LED*/
    if((PINB & 0x01) == 0 ) {

      PORTC = ~(1<<PC0);
      uart_putc('a');

      while((PINB & 0x01) == 0) {}

    } else {
      PORTC = ~(1<<PC1);
    }
  }

  return 0;
}

uart.h

/* uart.h */

#ifndef UART_H
#define UART_H

#include <avr/io.h>

extern void uart_init (void);

static inline int uart_putc (const uint8_t c) {

  /* wait until UDR is ready for new value */
  while (!(UCSRA & (1 << UDRE)));

  /* write UDR starts transmission */
  UDR = c;

  return 1;
}

static inline uint8_t uart_getc_wait (void) {

  /* wait until something was received */
  while (!(UCSRA & (1 << RXC)));

    /* return received char */
    return UDR;
}

static inline int uart_getc_nowait (void) {

  /* return received char or -1 */
  return (UCSRA & (1 << RXC)) ? (int) UDR : -1;
}

#endif /* UART_H  */

uart.c

/* uart.c */

#include "uart.h"

#define BAUD        9600UL
#define UBRR_BAUD   ((F_CPU/(16UL*BAUD))-1)

void uart_init (void) {

  UBRRH = (uint8_t) (UBRR_BAUD>>8);
  UBRRL = (uint8_t) (UBRR_BAUD & 0x0ff);


  /* turn on UART receiver and transmitter */
  /* data mode 8N1, asynchronous */
  UCSRB = (1 << RXEN) | (1 << TXEN);
  UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);

  /* flush receiver register (remove invalid values) */
    do
    {
        UDR;
    }
    while (UCSRA & (1 << RXC));
}

An der Hardware habe ich fast nichts verändert, ich habe das 8MHz Quarz 
gegen ein 16MHz Quarz ersetzt. Im Makefile habe ich somit F_CPU auf 
16000000UL gesetzt.

Die Ausgabe des Compilers sieht wie folgt aus:

make all 
Building file: ../main.c
Invoking: AVR Compiler
avr-gcc -Wall -Os -fpack-struct -fshort-enums -std=gnu99 -funsigned-char -funsigned-bitfields -mmcu=atmega8 -DF_CPU=16000000UL -MMD -MP -MF"main.d" -MT"main.d" -c -o "main.o" "../main.c"
Finished building: ../main.c
 
Building file: ../uart.c
Invoking: AVR Compiler
avr-gcc -Wall -Os -fpack-struct -fshort-enums -std=gnu99 -funsigned-char -funsigned-bitfields -mmcu=atmega8 -DF_CPU=16000000UL -MMD -MP -MF"uart.d" -MT"uart.d" -c -o "uart.o" "../uart.c"
Finished building: ../uart.c
 
Building target: uart_simple.elf
Invoking: AVR C Linker
avr-gcc -Wl,-Map,uart_simple.map -mmcu=atmega8 -o "uart_simple.elf"  ./main.o ./uart.o   
Finished building target: uart_simple.elf
 
Invoking: AVR Create Extended Listing
avr-objdump -h -S uart_simple.elf  >"uart_simple.lss"
Finished building: uart_simple.lss
 
Create Flash image (ihex format)
avr-objcopy -R .eeprom -O ihex uart_simple.elf  "uart_simple.hex"
Finished building: uart_simple.hex
 
Create eeprom image (ihex format)
avr-objcopy -j .eeprom --no-change-warnings --change-section-lma .eeprom=0 -O ihex uart_simple.elf  "uart_simple.eep"
Finished building: uart_simple.eep
 
Invoking: Print Size
avr-size --format=avr --mcu=atmega8 uart_simple.elf
AVR Memory Usage
----------------
Device: atmega8

Program:     164 bytes (2.0% Full)
(.text + .data + .bootloader)

Data:          0 bytes (0.0% Full)
(.data + .bss + .noinit)


Finished building: sizedummy

Da ich die Taktquelle geändert habe, musste ich auch die Fuses ändern zu 
High: 0xd9 und Low: 0xff.

Ausgabe von AVRDude

Launching /usr/local/CrossPack-AVR-20130212/bin/avrdude -pm8 -cavrisp2 -Pusb -u -Uflash:w:uart_simple.hex:a -Ulfuse:w:0xff:m -Uhfuse:w:0xd9:m 
Output:

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.01s

avrdude: Device signature = 0x1e9307
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
         To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "uart_simple.hex"
avrdude: input file uart_simple.hex auto detected as Intel Hex
avrdude: writing flash (164 bytes):

Writing | ################################################## | 100% 0.08s

avrdude: 164 bytes of flash written
avrdude: verifying flash memory against uart_simple.hex:
avrdude: load data flash data from input file uart_simple.hex:
avrdude: input file uart_simple.hex auto detected as Intel Hex
avrdude: input file uart_simple.hex contains 164 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.05s

avrdude: verifying ...
avrdude: 164 bytes of flash verified
avrdude: reading input file "0xff"
avrdude: writing lfuse (1 bytes):

Writing | ################################################## | 100% 0.00s

avrdude: 1 bytes of lfuse written
avrdude: verifying lfuse memory against 0xff:
avrdude: load data lfuse data from input file 0xff:
avrdude: input file 0xff contains 1 bytes
avrdude: reading on-chip lfuse data:

Reading | ################################################## | 100% 0.00s

avrdude: verifying ...
avrdude: 1 bytes of lfuse verified
avrdude: reading input file "0xd9"
avrdude: writing hfuse (1 bytes):

Writing | ################################################## | 100% 0.00s

avrdude: 1 bytes of hfuse written
avrdude: verifying hfuse memory against 0xd9:
avrdude: load data hfuse data from input file 0xd9:
avrdude: input file 0xd9 contains 1 bytes
avrdude: reading on-chip hfuse data:

Reading | ################################################## | 100% 0.00s

avrdude: verifying ...
avrdude: 1 bytes of hfuse verified

avrdude done.  Thank you.

avrdude finished

***FEHLERQUELLE:***
Nun habe ich nochmal mit meinem Logic Sniffer eine Messung durchgeführt 
und bin bei 9600 Baud auf das folgende Ergebnis gekommen:
https://dl.dropboxusercontent.com/u/6454333/mikrocontoller.net/uart_measure_9600_baud.png

Laut Wikipedia beträgt die Bitzeit bei einer Baudrate von 9600: 104us 
(Quelle: http://de.wikipedia.org/wiki/UART). Bei meiner Messung bin ich 
aber auf eine Bitzeit von 454us gekommen, also mehr als 4 mal so lang.


Checklist 3.2:
+ Int. Oszillator wird nicht verwendet sondern 16MHz Quarz.
+ Habe nur 8MHz und 16MHz zur Hand.
+ Taktrate wird genau angegeben über F_CPU während des Kompilierens.
+ entfällt, s.o.
+ Fuses sind folgendermaßen eingestellt: High: 0xd9, Low: 0xff (ext. 
crystal / resonator high freq.; start-up time 16K CK + 64ms) siehe: 
http://www.engbedded.com/fusecalc/
+ CLKDIV gibt es nicht beim ATmega8.
+ entfällt, s.o.
+ Wenn ich das Quarz während der Laufzeit entferne, geht nichts mehr => 
Quarz wird somit als Taktquelle verwendet.
+ Hier liegt der Fehler, aber ich weiß nicht wo?
+ URSEL bit ist gesetzt.
+ Habe ich gelesen und verstanden

Sonstige Fehlerquellen:
+ Datenübertragung "funktioniert" (Wenn ich den Taster drücke wird etwas 
gesendet, ansonsten ist es still)
+ Ich gehe davon aus dass das STK500 das regelt.
+ PD0 auf RX und PD1 auf TX.
+ Ja, alle Programme wurden auf die Baudrate 9600 und 8N1 gestellt.
+ Ich kann mit dem USB-zu-Seriell Adapter ohne Probleme eine AVR auf dem 
STK500 programmieren => USB-zu-Seriell funktioniert.
+ Nein.
+ Welche Pins sind gemeint? Ein D-Sub 9 habe nur 9 Pins + Masse über das 
Gehäuse.

Ich hoffe ich habe keine Details übersehen.

Viele Grüße

konze

[Konstantin L. (konze)]

Nachtrag:
Ich habe soeben das folgende Programm auf den ATmega8 geladen:

/* main.c */

#include <avr/io.h>
#include <util/delay.h>

int main(void) {

  /* set PB0 as input */
  DDRB = ~0x01;
  PORTB = 0x01;

  /* set PD0-1 as output */
  DDRD = 0xff;
  PORTD = ~0x00;

  /* set PC0-1 as output*/
  DDRC = 0x03;
  PORTC = ~0x02;

  while(1) {
    if((PINB & 0x01) == 0 ) {
      break;
    }
  }

  PORTC = ~0x01;

  while(1) {
    PORTD = 0xff;
    _delay_ms(1000);
    PORTD = 0x00;
    _delay_ms(1000);
  }

  return 0;
}

Fuses und Hardware wie eben.

Wenn ich mit meinem Logic Sniffer die Zeit messe zwischen positiver und 
negativer Flanke an PD0 dann beträgt die Dauer nicht 1s sondern 4,5. 
Dies ist fast genau der selbe Faktor wie er auch bei den Zeiten am UART 
auftritt. Ich hoffe dies dient zu Lösung des Problems.

Viele Grüße

konze

[Stefan E. (sternst)]

Konstantin Lübeck schrieb:
> Laut Wikipedia beträgt die Bitzeit bei einer Baudrate von 9600: 104us
> (Quelle: http://de.wikipedia.org/wiki/UART). Bei meiner Messung bin ich
> aber auf eine Bitzeit von 454us gekommen, also mehr als 4 mal so lang.

Das entspricht ziemlich genau einer anderen gebräuchlichen 
Quarzfrequenz, nämlich 3,6864 MHz. Also Lupe raus holen, und nochmal 
schauen, was tatsächlich auf dem Quarz steht.

Nachtrag: Ich bin nicht wirklich vertraut mit dem STK500, aber ist 
3,6864 MHz nicht auch die Standardeinstellung des STK500-Taktgenerators? 
Also auch noch mal checken, ob das STK500 richtig für die Verwendung 
eines Quarzes konfiguriert ist. Ja, ich weiß, dein Quarz-Zieh-Test 
scheint das zu belegen, die Symptome sprechen aber dagegen.

[Konstantin L. (konze)]

Ich habe den Fehler gefunden:
Auf dem STK500 gibt es einen Jumper OSCSEL dieser hat zwei Positionen 0 
und 1.
Wenn man den Jumper auf 1 steckt, dann wird eine vom STK500 generierte 
Frequenz angelegt nämlich: 3,6864 MHz.
Wenn man den Jumper auf 0 steckt, dann wird das Quarz welches man in den 
Sockel CRYSTAL gesteckt als Taktquelle verwendet.

Ich hatte die ganze Zeit den OSCSEL Jumper in der falschen Stellung. 
Jetzt Funktioniert alles wunderbar.

Viele Dank an alle!

konze