Hallo,

so, jetzt ist es soweit, ich brauche auch mal Eure Hilfe. Bis jetzt hab ich mir durch dieses Forum immer selbst helfen können, hab fleißig die Suche und das Wiki benutzt und alles hat am Ende so funktioniert wie es sollte. Aber jetzt komm ich einfach nicht weiter, vielleicht kann mir ja hier einer helfen.

Und zwar möchte ich die Kommunikation zwischen PC und µC endlich auf die Reihe kriegen: Die Variante 1 aus dem Wiki mittels Polling funktioniert in beide Richtungen, aber bei Variante 2 (mit Interrupts) funktioniert nur das Senden, beim Empfangen tut sich nichts.

[Problem_gelöst]
Zuerst aber ein kurioses Problem: Ich muss im Terminal eine Baudrate von 1200 einstellen, beim µC habe ich eine Baudrate von 9600 eingestellt. Ansonsten funktioniert es nicht - Ich habe keine Ahnung warum, vielleicht weiß ja auch das einer von euch.
[/Problem_gelöst]

Hier meine Codes:

uart.h:
Code:
#ifndef _UART_H_
#define _UART_H_

#include <avr/io.h>

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

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

#endif
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);
	UCSR0C = (1<<UMSEL01) | (1<<UCSZ01) | (1<<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);
}
Und das Hauptprogramm:
Code:
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdavr.h>
#include <stdlib.h>
#include "fifo.h"
#include "uart.h"
#include "lcd.h"
#include <inttypes.h>

int main()
{
	char c = 'a';
	
	uart_init();
	lcd_init(LCD_DISP_ON);
	
	sei();
	
	while(1){
		
		lcd_gotoxy(0,0);
		lcd_puts("Test");
		
		lcd_gotoxy(0,1);
		lcd_putc(c);
		
		uart_puts("Test");
		
		c = uart_getc_wait();
	}
}
Am Terminal kommt der Text ("Test") an, nur wenn ich ein Zeiche sende, passiert nichts. Normal müßte ja nach dem Senden des Zeichens die Schleife wieder von vorne losgehen und weitere "Test"s auf dem Terminal ankommen. Tuts aber nicht. Es hängt also irgendwo am Empfangen, bzw. am FFIO.

Ich würde mich sehr freuen, wenn mal jemand von Euch über den Code gucken könnte und sieht, ob irgendwo ein Fehler ist..

Vielen Dank, Markus