Atmega8 empfängt bestimmte Bytes falsch über UART

[Konstantin L. (konze)]

Hallo zusammen,

nach einer längeren Pause (ein ganzes Informatikstudium) habe ich mal 
wieder mein STK500 ausgepackt und ein wenig herumprobiert. Das C 
Programm welches ich für den Atmega8 programmiert habe, empfängt über 
den UART ein Bytes welches ich vom meinem Computer sende, anschließend 
antwortet mir die Interrupt Service Routine ISR mit der Binärdarstellung 
des übertragenen Bytes (ich habe diese Programm geschrieben da ich zuvor 
Probleme hatte mit der Kommunikation).
Wenn ich dem Controller die Bytes 0x00, 0x01, 0x02, ..., 0x1f sende 
erhalte ich als Antwort die korrekte Binärdarstellung des Bytes. Sobald 
ich aber Bytes sende die größer sind als 0x1f bekomme ich eine 
Fehlerhafte Binärdarstellung als Antwort.

Hier ist der Programmcode:

// clock frequency 1Mhz 
#define F_CPU 1000000UL

// baud rate
#define BAUD 9600
#define BAUDRATE ((F_CPU)/(BAUD*16UL)-1)

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


void uart_init (void);
void uart_putc (unsigned char data);
void uart_puts (unsigned char * str, uint8_t size);

// interrupt service routine for UART receiver interupt
ISR(USART_RXC_vect) {

    // get received char
    unsigned char received_char = UDR;

    uart_puts("received=", 9);

    if((received_char & (1<<7)) == (1<<7)) {
        uart_putc('1');
    } else {
        uart_putc('0');
    }

    if((received_char & (1<<6)) == (1<<6)) {
        uart_putc('1');
    } else {
        uart_putc('0');
    }

    if((received_char & (1<<5)) == (1<<5)) {
        uart_putc('1');
    } else {
        uart_putc('0');
    }

    if((received_char & (1<<4)) == (1<<4)) {
        uart_putc('1');
    } else {
        uart_putc('0');
    }

    if((received_char & (1<<3)) == (1<<3)) {
        uart_putc('1');
    } else {
        uart_putc('0');
    }

    if((received_char & (1<<2)) == (1<<2)) {
        uart_putc('1');
    } else {
        uart_putc('0');
    }

    if((received_char & (1<<1)) == (1<<1)) {
        uart_putc('1');
    } else {
        uart_putc('0');
    }

    if((received_char & (1<<0)) == (1<<0)) {
        uart_putc('1');
    } else {
        uart_putc('0');
    }

    uart_puts("\n\r",2);
}


// function to initialize UART
// dataformat 8N1
void uart_init (void) {

    // shift the register right by 8 bits
    UBRRH = (BAUDRATE>>8);

    // set baud rate
    UBRRL = BAUDRATE;            

    // enable receiver, transmitter and receiver interrupt
    UCSRB|= (1<<TXEN)|(1<<RXEN)|(1<<RXCIE);

    // 8bit data format
    UCSRC|= (1<<URSEL)|(1<<UCSZ0)|(1<<UCSZ1);   

}

// sends a single char over the UART
void uart_putc (unsigned char data) {

    // wait while register is free
    while (!( UCSRA & (1<<UDRE)));
    // load data in the register
    UDR = data;
}

// sends a string over the UART
void uart_puts (unsigned char * str, uint8_t size) {

    uint8_t i; 

    for(i = 0; i < size; i++) {
        uart_putc(str[i]);
    }
}

// receives a single char over the UART
unsigned char uart_getc (void) {

    // wait while data is being received
    while(!(UCSRA) & (1<<RXC));
    // return 8-bit data
    return UDR;
}


uint8_t main (void) {

    // enable interrupts
    sei();

    // enable uart
    uart_init(); 

    uart_puts("ready\n\r", 7);

    while(1) {
    } 

    return 0; 
}

Angehängt habe ich eine Screenshot von der Kommunikation mit dem 
Atmega8. Hier werden hintereinander die folgenden Bytes übertragen:
0x01, 0x02, 0x03, 0x1d, 0x1e, 0x1f und 0x20. Für 0x20 sollte ich aber 
00100000 empfangen anstatt 01100000.

Ich hoffe ihr könnt mir helfen.

Vielen Dank und viele Grüße

Konze

[m.n. (Gast)]

Ohne jetzt genau nachzurechnen: 9600 Bd @ 1 MHz?
Die Baudrate scheint mir ein wenig zu ungenau zu werden.

[Klaus (Gast)]

Informatikstudium? Hüstel. In der Baumschule? (Entschuldige, aber 
irgendwie konnte ich mir das nicht verkneifen).


Ich zitiere da mal Falk: In einer Interruptroutine macht man nichts als 
ein Flag zu setzen und das dann in der Hauptschleife zu verarbeiten.

Verschiebe mal das ganze Gewusel in eine eigene Funktion. Und die ganzen 
einzelnen if-Befehle kannst Du Dir sparen. Ist ja furchtbar - 
insbesondere für jemanden, der das studiert hat ist das eher "AUA".

   unsigned char i;
   for (i = 0x80; i != 0; i >>= 1)
     uart_putc(0x30 + (received_char & i) ? 1 : 0);

(Ist nicht kompiliert worden).

[chris_ (Gast)]

>Informatikstudium? Hüstel. In der Baumschule? (Entschuldige, aber
>irgendwie konnte ich mir das nicht verkneifen).

Ist mir auch etwas sauer aufgestoßen. Allerdings ist der Code relativ 
klar und man sollte die Strukturen einfach halten und keine 
Verschachtelungen verwenden.
Dein Code dürfte nicht direkt den MISRA-Rules entsprechen. Außerdem 
sollte man der "Klarheit" wegen uint8_t aus der stdlib.h anstatt 
"unsigned char" verwenden.

[Klaus (Gast)]

Ach und achte darauf zwischen den gesendeten Zeichen lange Pausen zu 
machen. Du sendest rund die 16-fache Datenmenge die Du empfängst. Oder 
Du nimmst einen Puffer, der dann aber die notwendige Pause lediglich 
nach hinten verschiebt.

So etwas solltest Du aber eigentlich wissen. :-)

[Konstantin L. (konze)]

@m.n.: Danke für deine Antwort! mit 8MHz funktioniert es nun

Zum Code: der ist nicht für den Produktiven Einsatz gedacht sondern 
dafür dem Fehler auf die schliche zu kommen.

[Stefan F. (Gast)]

Wenn kleine Werte nocht korrekt übertragen werden, und Fehler erst 
auftreten, wenn die oberen Bits 1 sind, dann liegt es mit sehr hoher 
warscheinlichkeit an einem ungenauen Takt.

Falls du den internen R/C Oszillator verwendest, kann es daran liegen. 
Der R/C Oszillator aller ATmegas eigent sich nicht für zuverlässige UART 
Kommunikation.

Laut Datenblatt des ATmega 8 Seite 159 hast du bei der Kombination 1Mhz 
9600Baud schon 7% Abweichung vom Soll - unter der Annahne, dass die 1Mhz 
100% stimmen. Wenn du das mit 10 Multiplizierst (1 Startbit, 8 
Datenbits, 1 Stopbit) hast du 70%. Für eine funktionierende Übertragung 
musst du unter 50% bleiben.

Also selbst mit einek 1Mhz Quarz würde das nicht zuverlässig 
funktionieren.

Wechsle auf 4800 Baud. Dann hast du bei einer idealen 1Mhz Quelle nur 
noch 0,2% Abweichung. Da stehen die Chancen auch viel besser, dass es 
mit R/C Oszillator klappt.

Wenn der R/C Oszillator z.B. 3% vom Soll abweicht, und du dazu die 0,2% 
addierst und das dann mit 10 Bits multiplizierst, hast du insgesamt 32% 
Abweichung. Das ist deutlich unter 50% - also gut.

[Stefan F. (Gast)]

Nachtrag: Wenn du das U2X Bit auf 1 setzt und UBBR verdoppelst (auf 12), 
dann werden die 9600Mhz auch mit nur 0,2% Abweichung erzeugt. Auch da 
sgeht aus der Tabelle auf Seite 159 hervor.

Wenn du einen anderen ATmega verwendest, schau halt in dessen 
Datenblatt. Ich glaube, das Prinzip ist jedoch bei allen Atmegas gleich.

[Konstantin L. (konze)]

@Stefan: Vielen Dank für deine Antwort! Sehr aufschlussreich.