Juchuuu,

so, habe mir jetzt mal die Zeit genommen, das Datenblatt ganz durchzulesen (jaja, ich weiß, soll man sowieso immer machen, ich hab halt geglaubt, dass der Quelltext im Wiki funktioniert....) und siehe da, die Aktivierung vom Receive-Interrupt hat gefehlt...

Und für alle die das gleiche Problem haben, bzw. einen (bei mir) funktionierenden Quelltext haben wollen, hier isser:

Test.c:
Code:
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include "fifo.h"
#include "uart.h"
#include "lcd.h"


int main(void)
{
	char c = 'a';
	
	uart_init();
	lcd_init(LCD_DISP_ON);
	
	sei();
	
	while(1){
		
		lcd_gotoxy(0,0);
		lcd_puts("Test");

		c = (char) uart_getc_wait();
		
		lcd_gotoxy(0,1);
		lcd_putc(c);
		
		uart_putc(c);
	}
}
uart.h:
Code:
#ifndef _UART_H_
#define _UART_H_

#include <avr/io.h>

extern void uart_init(void);
extern int uart_putc(const uint8_t);
extern uint8_t uart_getc_wait(void);
extern int	   uart_getc_nowait(void);
//extern void uart_write_fifo(const uint8_t);

static inline void uart_flush(void)
{
	while (UCSR0B & (1<<UDRIE0));
}

#endif
und uart.c:
Code:
#include <avr/io.h>
#include <avr/interrupt.h>
#include "uart.h"
#include "fifo.h"

#define BAUDRATE	9600

// 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;

void uart_init()
{
	uint8_t sreg = SREG;
	uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/(16L*BAUDRATE) - 1);
	
	UBRR0H = (uint8_t) (ubrr>>8);
	UBRR0L = (uint8_t) (ubrr);
	
	// Interrupts kurz deaktivieren
	cli();

	// UART Receiver und Transmitter anschalten
	// Data mode 8N1, asynchron
	UCSR0B = (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE0);
	UCSR0C = (1<<USBS0) | (3<<UCSZ00);
	
	//Flush Receive-Buffer (entfernen evtl. vorhandener ungültiger Werte)
	do
	{
		UDR0;
	}
	while (UCSR0A & (1<<RXC0));
	
	// Rücksetzen von Receive und Transmit Complete-Flags
	UCSR0A = (1<<RXC0)|(1<<TXC0);
	
	// Global Interrupt-Flag wiederherstellen
	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);
	
	UCSR0B |= (1<<UDRIE0);
	
	return ret;
}

void uart_puts(const char *s)
{
	do
	{
		uart_putc(*s);
	}
	while(*s++);
}

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

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

// Empfangene Zeichen werden in die Eingangs-FIFO gespeichert und warten dort
SIGNAL(SIG_USART_RECV)
{
	_inline_fifo_put(&infifo, UDR0);
}

// Ein Zeichen aus der Ausgabe-FIFO lesen und ausgeben
// Ist das Zeichen fertig ausgegeben, wird ein neuer SIG_UART_DATA_IRQ getriggert
// Ist die FIFO leer, deaktiviert die ISR ihren eigenen IRQ.
SIGNAL(SIG_USART_DATA)
{
	if (outfifo.count > 0)
		UDR0 = _inline_fifo_get(&outfifo);
	else
		UCSR0B &= ~(1<<UDRIE0);
}
Vielen Dank auch an Superhirn wegen des Tips mit dem divide-by-8-Bits.

Markus