das mache ich in uart.h:
unter uart_init():
Code:
/* * uart.h
 *
 *  Created on: 12.05.2012
 *      Author: rainer
 */


#ifndef UART_H_
#define UART_H_


#include <avr/io.h>
#include <avr/interrupt.h>
#include "fifo.h" // erklärt im Artikel "FIFO mit avr-gcc"


// FIFO-Objekte und Puffer für die Ein- und Ausgabe


#define BUFSIZE_IN  0x40
uint8_t inbuf[BUFSIZE_IN];
fifo_t infifo;


#define BUFSIZE_OUT 0x40
uint8_t outbuf[BUFSIZE_OUT];
fifo_t outfifo;


//Variable zum Dummy auslesen
uint8_t dummy;


void uart_init (void)
{
    uint8_t sreg = SREG;




    UBRRH = 0;                //Highbyte ist 0
    UBRRL = 51;                //Lowbyte ist 103 (dezimal)
                            //-> (Frequenz_in_Hz / (Baudrate * 16)) - 1 <- Quarzfrequenz = 16*1000*1000 Hz!!!!


    // Interrupts kurz deaktivieren
    cli();


    // UART Receiver und Transmitter anschalten, Receive-Interrupt aktivieren
    // Data mode 8N1, asynchron
    UCSRB = (1 << RXEN) | (1 << TXEN) | (1 << RXCIE);
    UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);


    // Flush Receive-Buffer (entfernen evtl. vorhandener ungültiger Werte)
    do
    {
        // UDR auslesen (Wert wird nicht verwendet)
        dummy = UDR;
    }
    while (UCSRA & (1 << RXC));


    // Rücksetzen von Receive und Transmit Complete-Flags
    UCSRA = (1 << RXC) | (1 << TXC);


    // Global Interrupt-Flag wieder herstellen
    SREG = sreg;


    // FIFOs für Ein- und Ausgabe initialisieren
    fifo_init (&infifo,   inbuf, BUFSIZE_IN);
    fifo_init (&outfifo, outbuf, BUFSIZE_OUT);
}




int uart_putc (const uint8_t c)
{
    int ret = fifo_put (&outfifo, c);


    UCSRB |= (1 << UDRIE);


    return ret;
}


int uart_getc_nowait (void)
{
    return fifo_get_nowait (&infifo);
}


uint8_t uart_getc_wait (void)
{
    return fifo_get_wait (&infifo);
}


// Einen 0-terminierten String übertragen.
void uart_puts (const char *s)
{
    do
    {
        uart_putc (*s);
    }
    while (*s++);
}


#endif /* UART_H_ */
hier noch fifo.h:
Code:
/* * fifo.h
 *
 *  Created on: 12.05.2012
 *      Author: rainer
 */


#ifndef FIFO_H_
#define FIFO_H_


#include <avr/io.h>
#include <avr/interrupt.h>


typedef struct
{
    uint8_t volatile count;       // # Zeichen im Puffer
    uint8_t size;                 // Puffer-Größe
    uint8_t *pread;               // Lesezeiger
    uint8_t *pwrite;              // Schreibzeiger
    uint8_t read2end, write2end;  // # Zeichen bis zum Überlauf Lese-/Schreibzeiger
} fifo_t;


extern void fifo_init (fifo_t*, uint8_t* buf, const uint8_t size);
extern uint8_t fifo_put (fifo_t*, const uint8_t data);
extern uint8_t fifo_get_wait (fifo_t*);
extern int fifo_get_nowait (fifo_t*);


static inline uint8_t
_inline_fifo_put (fifo_t *f, const uint8_t data)
{
    if (f->count >= f->size)
        return 0;


    uint8_t * pwrite = f->pwrite;


    *(pwrite++) = data;


    uint8_t write2end = f->write2end;


    if (--write2end == 0)
    {
        write2end = f->size;
        pwrite -= write2end;
    }


    f->write2end = write2end;
    f->pwrite = pwrite;


    uint8_t sreg = SREG;
    cli();
    f->count++;
    SREG = sreg;


    return 1;
}


static inline uint8_t
_inline_fifo_get (fifo_t *f)
{
    uint8_t *pread = f->pread;
    uint8_t data = *(pread++);
    uint8_t read2end = f->read2end;


    if (--read2end == 0)
    {
        read2end = f->size;
        pread -= read2end;
    }


    f->pread = pread;
    f->read2end = read2end;


    uint8_t sreg = SREG;
    cli();
    f->count--;
    SREG = sreg;


    return data;
}




void fifo_init (fifo_t *f, uint8_t *buffer, const uint8_t size)
{
    f->count = 0;
    f->pread = f->pwrite = buffer;
    f->read2end = f->write2end = f->size = size;
}


uint8_t fifo_put (fifo_t *f, const uint8_t data)
{
    return _inline_fifo_put (f, data);
}


uint8_t fifo_get_wait (fifo_t *f)
{
    while (!f->count);


    return _inline_fifo_get (f);
}


int fifo_get_nowait (fifo_t *f)
{
    if (!f->count)        return -1;


    return (int) _inline_fifo_get (f);
}






#endif /* FIFO_H_ */