Problem mit UART beim empfangen

[Lisa K. (lissy)]

Hallo an alle,

erst mal ich bin ein absoluter Neuling in diesem Gebiet, verzeicht mir 
also bitte meine (Anfänger-) Fehler =)

Ich möchte Daten zwischen einem Terminal (PC über RS-232) und meinem 
Mikrocontroller (ATMEGA 164 PA) austauschen. Beim senden vom atmega an 
den PC sehe ich die Zeichen auch auf dem Terminal, nur das empfangen 
klappt nicht so recht

Programmaufbau (theoretisch):
UART initialisieren
leere Endlosschleife
Interrupt wenn Controller Daten senden soll (TX)
Interrupt wenn Controller Daten empfangen soll (RX)

Die Daten sollen dann entweder direkt in der ISR gesendet/empfangen 
werden oder in der ISR soll ein Flag gesetzt werden, welches dann in der 
Endlosschleife überprüft wird.

Ich hoffe das war jetzt verständlich...wär lieb wenn jemand helfen 
könnte
 danke schon mal an alle


Hier noch mein Codevorschlag:

//Header einbinden
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
#include <avr/interrupt.h>

//Definitionen
#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7
#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<OVR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)


//Prototypen der Funktionen
void USART_Init( unsigned int baud );
void sendenByte( unsigned char data );
unsigned char empfangenByte( void );


int main(void)
{

    
    //UART initialisieren
    USART_Init(9600);
    UCSR0B = (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0);
    //Interrupts aktivieren
    sei();
    
  
    while(1)
    {
    }
}

void USART_Init( unsigned int baud )
{
  //Baudrate setzen: (8MHz / (16*baud))-1 = 51 --> 33hex
  UBRR0H=0x0;
  UBRR0L=0x33;
  //keine error-bits gesetzt
  UCSR0A = 0x00;
  //Interrupts enable, receiver und transmitter enable
  UCSR0B = 0xF8;
  //asynchroner modus, kein parity bit, 1 stop bit, 8 datenbits
  UCSR0C = 0x06;
  //Global Interrupt Flag loeschen (Bit 0 bei SREG)
  //SREG &= ~(1 << 0);
}


void sendenByte( unsigned char data )
{
  //Sendekanal aktivieren (Bit 3 in UCSR1B)
  UCSR0B &= ~(1 << TXEN0);
  //pruefen ob vorherige Uebertragung abgeschlossen
  if ((UCSR0A & (1 << UDRE0)))
  {
    for (int i=8; i<=0; i--)
    {
      UDR0 = data;
      //UCSR1A |= (1 << UDRE1);
    }
    UDR0 = data;
  } else
  {
    sendenByte(data);
  }
  //Receiver wieder enable
  UCSR0B |= (1 << TXEN0);
}

unsigned char empfangenByte( void )
{
  unsigned char data;
  //Emfangskanal aktivieren (Bit 4 in UCSR1B
  UCSR0B &= ~(1 << RXEN0);
  //solange RXC noch nicht gesetzt Daten empfangen
  if (UCSR0A | (1 << RXC0))
  {
    for (int i=8; i<=0; i--)
    {
      //Daten empfangen
      data = UDR0;
    }
  }

  return data;
}

 ISR  (USART0_TX_vect)
 {
    sendenByte(0xAA);
 }
 ISR (USART0_RX_vect)
 {
   empfangenByte();
 }

[Karl H. (kbuchegg)]

unsigned char empfangenByte( void )
{
  unsigned char data;
  //Emfangskanal aktivieren (Bit 4 in UCSR1B
  UCSR0B &= ~(1 << RXEN0);
  //solange RXC noch nicht gesetzt Daten empfangen
  if (UCSR0A | (1 << RXC0))
  {
    for (int i=8; i<=0; i--)
    {
      //Daten empfangen
      data = UDR0;
    }
  }

  return data;
}

das ist Quatsch.

Erst mal: lass die Enable Bits in Ruhe. Zweites brauchst du auch nicht 
prüfen, ob etwas empfangen wurde. Die ISR wurde aufgerufen WEIL etwas 
empfangen wurde - d.h. du weißt an dieser Stelle, dass was da ist.
Drittens: wozu die for-Schleife? Der Interrupt wird für jedes Zeichen 
einzeln aufgerufen und ja - du MUSST das UDR auslesen.


ISR (USART0_RX_vect)
{
  char c = UDR;

  // mach was mit c
}

und lass die ENable Bits in Ruhe! Wenn die UART aktiv ist, dann bleibt 
sie auch die ganze Zeit aktiv.

[Paule H. (stk500-besitzer)]

Also entweder entscheidest du dich für einen Empfang per Interrupt oder 
per Polling. Momentan schmeisst du beides zusammen.

Hast du dich bei deinem Programm an den Besipielen im Datenblatt 
orientiert?

[Lisa K. (Gast)]

Danke schon mal für die Hilfe...

eigentlich würde ich das ganze gern Interrupt-gesteuert machen

orientiert habe ich mich am Datenblatt...wenn ich das allerdings 
übernommen habe, hat das bei mir nicht funktioniert =(

Hier die Funktion für das Empfangen aus dem Datenblatt

unsigned char USART_Receive( void )
{
    /* Wait for data to be received */
    while ( !(UCSRnA & (1<<RXCn)) );
/* Get and return received data from buffer */
return UDRn;
}


@ Karl Heinz Buchegger:
danke für den Tipp, wie gesagt bin blutiger Anfänger, unerfahren und 
noch etwas verwirrt =( hab das mal so ausprobiert, leider kann ich immer 
noch nichts empfangen, bin ich echt so blöd =(

[Karl H. (kbuchegg)]

Das hier

void sendenByte( unsigned char data )
{
  //Sendekanal aktivieren (Bit 3 in UCSR1B)
  UCSR0B &= ~(1 << TXEN0);
  //pruefen ob vorherige Uebertragung abgeschlossen
  if ((UCSR0A & (1 << UDRE0)))
  {
    for (int i=8; i<=0; i--)
    {
      UDR0 = data;
      //UCSR1A |= (1 << UDRE1);
    }
    UDR0 = data;
  } else
  {
    sendenByte(data);
  }
  //Receiver wieder enable
  UCSR0B |= (1 << TXEN0);
}

ist .... ich sags nicht, was mir da auf der Zunge liegt.
Das ist eine rekursive Funktion, ist dir das bewusst, was damit 
zusammenhängt?

Ausserdem ist das viel zu kompliziert

void sendenByte( unsigned char data )
{
  while( !(UCSR0A & (1 << UDRE0))
    ;

  UDR0 = data;
}

das ist eine Funktion, die 1 Byte versendet. Wenn du mehrere Bytes 
verschicken willst, dann rufst du die Funktion eben mehrfach auf:

void sendeMehrfach( unsigned char c )
{
  uint8_t i;

  for( i = 0; i < 8; ++i )
    sendenByte( c );
}

Aber du musst VOR jeder Ausgabe an UDR prüfen, ob dir UDRE0 das 
überhaupt erlaubt. Du kannst nicht einfach 30 Bytes an UDR0 zuweisen. 
Der letzte Ansatz gewährleistet das, weil sendenByte genau das tut: Bei 
jedem einzelnen Byte so lange zuzuwarten, bis die UART wieder frei ist.

[Lisa K. (Gast)]

Also ich hab mal einen Breakpoint in die ISR gesetzt, leider wird die 
bei mir nie ausgeführt, der Sprung in den Interrupt wird durchgeführt...

Kann es sein dass "USART0_RX_vect" nie wahr wird, muss ich dafür erst 
etwas gesendet haben um in diese ISR zu kommen?

Tut mir Leid wenn ich mich so blöd anstelle, aber ich weiß es wirklich 
nicht besser, hab davor eher Java, etc. gemacht

[Karl H. (kbuchegg)]

Hast du irgendwelche Warnungen vom Compiler.
Irgendwas in Richtung: xxxxx seems to be an illegal Interrupt Name

> ISR (USART0_RX_vect)

meistens heißt die irgendwas in Richtung

ISR (USART0_RXC_vect)

RX steht für Receive und das C für Complete. Genau aus dem Grund heißt 
ja auch die Freigabe für den Interrupt

>     UCSR0B = (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0);


RXCIE0

  RX   Receive
  C    Complete
  I    Interrupt
  E    Enable
  0    der UART 0

[Karl H. (kbuchegg)]

Lisa K. schrieb:

> @ Karl Heinz Buchegger:
> danke für den Tipp, wie gesagt bin blutiger Anfänger, unerfahren und
> noch etwas verwirrt =( hab das mal so ausprobiert, leider kann ich immer
> noch nichts empfangen, bin ich echt so blöd =(


Dann solltest du vielleicht nicht gerade gleich mal mit Interrupts 
einsteigen.

AVR-GCC-Tutorial

[Lisa K. (Gast)]

Errors habe ich nicht, aber 2 Warnings:

#warning "F_CPU not defined for <util/delay.h>"

Warning  unused variable 'c'


xxxxx seems to be an illegal Interrupt Name  kommt bei mir nicht

[Karl H. (kbuchegg)]

Stimmt.

Der Vector heisst wirklich

#define USART0_RX_vect      _VECTOR(20)

(zu finden in iomxx4.h welches von iom64.h includiert wird, welches von 
io.h includiert wird - wenn die µC Einstellung stimmt.)

[Karl H. (kbuchegg)]

>   //Interrupts enable, receiver und transmitter enable
>  UCSR0B = 0xF8;


Was macht das alles?

Mach deine erste Kommunikation erst mal ohne INterrupts, ok?

[Lisa K. (Gast)]

mit polling habe ich es bereits versucht, dabei habe ich zumindest Daten 
auf dem Terminal erhalten

Hier mal der Code:

/*
 * Test_UART0.c
 *
 * Created: 14.05.2013 13:23:33
 *  Author: u56460
 */ 

//Header einbinden
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>

//Definitionen
#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7

#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<OVR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)


//Prototypen der Funktionen
void initUART( void);
void sendenByte( unsigned char data );


int main(void)
{
  initUART();
  
    while(1)
    {
    //Daten senden
    sendenByte(0xAA);
  
    }
}

void initUART( void )
{
  int ubrr;
  UCSR0A=0x00;
  // Receiver und Transmitter enable
  UCSR0B=0x18;
  //asynchroner Modus, kein Parity, 1 Stop Bit, 8 Datenbits
  UCSR0C=0x06;
  //Baudrate setzen:
  UBRR0H=0x00;
   UBRR0L=0x33;


  //analoger Comparator disable
  ACSR=0x80;
  // Analog Comparator Input Capture by Timer/Counter 1: Off
  //analoger Comparator Multiplexer enable
  ADCSRB=0x00;
  
}


void sendenByte( unsigned char data )
{
  //Sendekanal aktivieren (Bit 3 in UCSR1B)
  UCSR0B &= ~(1 << TXEN0);
  //pruefen ob vorherige Uebertragung abgeschlossen
  if ((UCSR0A & (1 << UDRE0)))
  {
    for (int i=8; i<=0; i--)
    {
      UDR0 = data;
      //UCSR1A |= (1 << UDRE1);
    }
    UDR0 = data;
  }  //Receiver wieder enable
  UCSR0B |= (1 << TXEN0);
}

Zudem sollte ich den Interrupt für eine Aufgabe für die Schule erledigen 
=(

[Lisa K. (Gast)]

Karl Heinz Buchegger schrieb:
>>   //Interrupts enable, receiver und transmitter enable
>
>>  UCSR0B = 0xF8;

das sollte laut Registerbeschreibung (wenn ich das so richtig verstanden 
habe) RXC Interrupt, TXC Interrupt und UDR empty Interrupt aktivieren, 
sowie den Empfänger und den Sender aktivieren

[Karl H. (kbuchegg)]

OK.

Paule hats oben schon gesagt: du hast da einen höllischen Mischmasch 
veranstaltet.

Langsam vorgehen. Eins nach dem anderen.
Geh von deiner Polling Lösung aus und mach erst mal nur den 
Empfangsinterrupt.

[Karl H. (kbuchegg)]

>   UCSR0B=0x18;
>  //asynchroner Modus, kein Parity, 1 Stop Bit, 8 Datenbits

Bitte nicht.
Die Bits haben Namen. Niemand hier hat Lust, das Datenblatt zu wälzen 
nur um rauszufinden, welche BIts du benutzt hast.

Im AVR-GCC-Tutorial gibt es einen Abschnitt über den UART. Orientier 
dich daran.

[Uwe (de0508)]

Anmerken möchte ich noch, dass manchmal überalterte Datenblätter 
verwendet werden.
Das kann dann zu Missverständnissen führen.

Die aktuellen enthalten i.a. weniger Fehler und mehr Erläuterungen:

http://www.atmel.com/Images/Atmel-8011-8-bit-AVR-Microcontroller-ATmega164P-324P-644P_datasheet.pdf

[Lisa K. (Gast)]

Also ich hab das Ganze jetzt noch eine Weile probiert, finde das gar 
nicht so einfach wie alle immer sagen :D

Danke noch an Uwe S. für das Datenblatt

Hier noch mal mein bisheriger Code (der leider immer noch nicht 
funktioniert)

//Header einbinden
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
#include <avr/interrupt.h>

//Definitionen
#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7

#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<OVR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)


//Prototypen der Funktionen
void USART_Init( void );
void sendenByte( unsigned char data );
void sendeMehrfach( unsigned char c );

//Variablen deklarieren
char receivedData;

int main(void)
{

    //UART initialisieren
    USART_Init();
    //Interrupts aktivieren
    //SREG |= (1<<7);
    
  
    while(1)
    {
    sendenByte(0xAA);
    }
}

void USART_Init( void )
{
  //Baudrate setzen: 8MHz, 9600 baud
         //33 hex nach Datenblatt-Tabelle
  UBRR0H=0x0;
  UBRR0L=0x33;
  //Interrupts enable
  UCSR0B |= (1 << RXCIE0);
  UCSR0B |= (1 << TXCIE0);
  UCSR0B |= (1 << UDRIE0);
  //Receiver und Transmitter enable
  UCSR0B |= (1 << RXEN0);
  UCSR0B |= (1 << TXEN0);
  //asynchroner modus, kein parity bit, 1 stop bit, 8 datenbits
  UCSR0C |= (1 << UCSZ01);
  UCSR0C |= (1 << UCSZ00);

}

void sendenByte( unsigned char data )
{
  while( !(UCSR0A & (1 << UDRE0)))
  ;

  UDR0 = data;
}


void sendeMehrfach( unsigned char c )
{
  uint8_t i;

  for( i = 0; i < 8; ++i )
  sendenByte( c );
}


//Daten erhalten (wenn es ungelesene Daten gibt, diese empfangen)
ISR (USART0_RX_vect)
{
  receivedData = UDR0;
}

Allerdings habe ich es noch nie geschafft, dass mit USART0_RX_vect oder 
USART0_TX_vect ein Interrupt ausgelöst wird. Bisher hat das bei mir nur 
mit USART0_UDRE_vect geklappt. Woran könnte das liegen oder was mache 
ich alles falsch?
Senden klappt inzwischen leider auch nicht mehr =(

[Cyblord -. (cyblord)]

Sehe kein sei() in deinem Code. Wie soll dann ein Interrupt ausgelöst 
werden?

Ah grade gesehen:

//Interrupts aktivieren
//SREG |= (1<<7);

Zwar auskommentiert aber da.

Dein Code ist furchtbar. Da schreibt man ein

sei();

um die Interrupts zu aktivieren.

gruß cyblord

[Uwe (de0508)]

Hallo Lisa.

wie Karl-Heinz schon schrieb, mache es erstmal ohne Interrupts.

Auch darfst Du nicht gleich alle ISR frei schalten, dann fehlen noch die 
passenden ISR dazu und du musst auch verstehen, wann einer der ISR frei 
geschaltet werden darf !

[Karl H. (kbuchegg)]

Lisa K. schrieb:

>   //Interrupts enable
>   UCSR0B |= (1 << RXCIE0);
>   UCSR0B |= (1 << TXCIE0);
>   UCSR0B |= (1 << UDRIE0);


Hüte dich vor solchen Rundumschlägen!

Wenn du einen INterrupt freigibst, dann MUSS es dafür auch eine ISR 
geben! Das ist ganz wichtig. Denn wenn du keine ISR dafür hast, dann 
tritt ein Default in Kraft, der zu einem µC-Reset führt!


Eventuell ist es für dich sinnvoll, am Programmstart, nachdem die UART 
initialisiert wird, erst mal einen bekannten Text (oder zeichen) 
auszugeben, damit dir solche Dinge nicht verborgen bleiben

void sendeString( char* text )
{
  while( *text )
    sendenByte( *text++ );
}


int main(void)
{
    //UART initialisieren
    USART_Init();
 

   sendeString( "Reset\n" );

   //Interrupts aktivieren
    //SREG |= (1<<7);

   sei();  // <------    
  
   while(1)
   {
     sendenByte(0xAA);
   }
}

Das geht allerdings nur so lange, solange du das Senden noch nicht über 
Interrupts abwickelst. Denn dann geht natürlich vor den sei() erst mal 
auch das Senden nicht. Aber bis dahin ist ja noch Zeit.

[Lisa K. (Gast)]

Ok also hier noch die abgeänderte Polling-Version:

//Header einbinden
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>

//Definitionen
#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7

#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<OVR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)



//Prototypen der Funktionen
void initUART( void);
void sendenByte( unsigned char data );
void sendeMehrfach( unsigned char c )´;
unsigned char empfangenByte( void );
void sendeString( char* text );

//Variablen deklarieren
unsigned char ausgabe;
int baud = 9600;


int main(void)
{
  initUART();
  
  sendeString( "Reset\n" );

  //Interrupts aktivieren
  sei();
  
    while(1)
    {
    //Daten senden
    sendenByte(0xAA);
  
    }
}

void USART_Init( void )
{
  //Baudrate setzen: 8MHz, 9600 baud --> 33 hex nach Datenblatt-Tabelle
  UBRR0H=0x0;
  UBRR0L=0x33;
  //Interrupts enable
  UCSR0B |= (1 << RXCIE0);
  UCSR0B |= (1 << TXCIE0);
  UCSR0B |= (1 << UDRIE0);
  //Receiver und Transmitter enable
  UCSR0B |= (1 << RXEN0);
  UCSR0B |= (1 << TXEN0);
  //asynchroner modus, kein parity bit, 1 stop bit, 8 datenbits
  UCSR0C |= (1 << UCSZ01);
  UCSR0C |= (1 << UCSZ00);

}


void sendenByte( unsigned char data )
{
  while( !(UCSR0A & (1 << UDRE0)))
  ;

  UDR0 = data;
}


void sendeMehrfach( unsigned char c )
{
  uint8_t i;

  for( i = 0; i < 8; ++i )
  sendenByte( c );
}
unsigned char empfangenByte( void )
{
  unsigned char data;
  //solange RXC noch nicht gesetzt Daten empfangen
  while (UCSR1A | (1 << RXC1))
  {
    //Daten empfangen
  }
  data = UDR1;
  return data;
}
void sendeString( char* text )
{
  while( *text )
  sendenByte( *text++ );
}

jetzt war ich nur so blöd und hab nicht ganz verstanden, was ich mit der 
sendeString Funktion anstellen soll...so wie ich das sehe, wird da reset 
übergeben...und solange ( *text ) soll diese Übergabevariable gesendet 
werden? Weiß nicht ob ich das o richtig verstanden habe, aber danke für 
deine Hilfe

Wenn ich den Code nun compilieren will, bekomme ich den Error 
stray'\246' in programm bei der Funktion sehndeMehrfach. Als ich nach 
dieser Fehlermeldung gegoolet habe, hieß es, dass keine boolean-Werte in 
Char gespeichert werden dürfen. Aber wo mache ich das?

Vielen Dank noch mal für eure Hilfe und Gedult

[Lisa K. (Gast)]

oh...das sei(); soll raus, das hab ich verstehentlich falsch kopiert

[gfhf (Gast)]

senden geht nicht weil du im ISR senden willst .. so deine INIT 
jedenfalls
versuch mal so ..

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

void USART_Init( void )
{
  UBRR0H = (uint8_t)(UBRR>>8);
  UBRR0L = (uint8_t) UBRR;

  UCSR0B = (1 << RXCIE0)|(1 << RXEN0)|(1 << TXEN0);

  UCSR0C = (1<<UCSZ01) | (1<<UCSZ00);
}

[gfhf (Gast)]

Lisa K. schrieb:
> UBRR0L=0x33;
>   //Interrupts enable
>   UCSR0B |= (1 << RXCIE0);
>   UCSR0B |= (1 << TXCIE0);
>   UCSR0B |= (1 << UDRIE0);
>   //Receiver und Transmitter enable

ist ja immernoch drin ?...

[Lisa K. (Gast)]

nun nochmals der Code ohne Interrupts mit Initialisierung von gfhf:

//Header einbinden
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>

//Definitionen
#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7

#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<OVR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)

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


//Prototypen der Funktionen
void USART_Init( void );
void sendenByte( unsigned char data );
void sendeMehrfach( unsigned char c );
unsigned char empfangenByte( void );
void sendeString( char* text );


int main(void)
{
  USART_Init();
  
  sendeString( "Reset\n" );

  
    while(1)
    {
    //Daten senden
    sendenByte(0xAA);
  
    }
}


void USART_Init( void )
{
  UBRR0H = (uint8_t)(UBRR>>8);
  UBRR0L = (uint8_t) UBRR;

  UCSR0B = (1 << RXCIE0)|(1 << RXEN0)|(1 << TXEN0);

  UCSR0C = (1<<UCSZ01) | (1<<UCSZ00);
}

void sendenByte( unsigned char data )
{
  while( !(UCSR0A & (1 << UDRE0)))
  ;

  UDR0 = data;
}

void sendeMehrfach( unsigned char c )
{
  uint8_t i;

  for( i = 0; i < 8; ++i )
  sendenByte( c );
}
unsigned char empfangenByte( void )
{
  unsigned char data;
  //solange RXC noch nicht gesetzt Daten empfangen
  while (UCSR1A | (1 << RXC1))
  {
    //Daten empfangen
  }
  data = UDR1;
  return data;
}
void sendeString( char* text )
{
  while( *text )
  sendenByte( *text++ );
}

Fehlermeldungen oder Warnings erhalte ich jetzt nicht mehr =)
Dankeschön dafür, leider kann ich immer noch nicht senden

[Uwe (de0508)]

Hallo,

ich will dich noch auf diesen Fehler hinweisen:

UCSR0A != UCSR1A

==> es gibt zwei usart im µC !

Also musst du auch die richtigen Pins beschalten !!!!

[Lisa K. (Gast)]

Uwe S. schrieb:
> UCSR0A != UCSR1A

oh...vielen Dank =)
habs geändert

[gfhf (Gast)]

er meint das da ...

Lisa K. schrieb:
> unsigned char empfangenByte( void )
> {
>   unsigned char data;
>   //solange RXC noch nicht gesetzt Daten empfangen
>   while (UCSR1A | (1 << RXC1))
>   {
>     //Daten empfangen
>   }
>   data = UDR1;
>   return data;
> }

du willst auf UART1 empfangen und auf UART0 senden ...
bitte entscheide dich ^^

[Lisa K. (Gast)]

das mit UART1 war versehentlich noch drin...aber inzwischen geht ja 
leider nicht mal mehr das senden...empfangen wurde in diesem Code ja gar 
nicht aufgerufen...

Hier trotzdem noch mal in verbesserter Form:

//Header einbinden
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>

//Definitionen
#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7

#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<OVR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)

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


//Prototypen der Funktionen
void USART_Init( void );
void sendenByte( unsigned char data );
void sendeMehrfach( unsigned char c );
unsigned char empfangenByte( void );
void sendeString( char* text );



int main(void)
{
  USART_Init();
  sendeString( "Reset\n" );
  
    while(1)
    {
    //Daten senden
    sendenByte(0xAA);
    }
}


void USART_Init( void )
{
  UBRR0H = (uint8_t)(UBRR>>8);
  UBRR0L = (uint8_t) UBRR;

  UCSR0B = (1 << RXCIE0)|(1 << RXEN0)|(1 << TXEN0);

  UCSR0C = (1<<UCSZ01) | (1<<UCSZ00);
}


void sendenByte( unsigned char data )
{
  while( !(UCSR0A & (1 << UDRE0)))
  ;

  UDR0 = data;
}


void sendeMehrfach( unsigned char c )
{
  uint8_t i;

  for( i = 0; i < 8; ++i )
  sendenByte( c );
}
unsigned char empfangenByte( void )
{
  unsigned char data;
  //solange RXC noch nicht gesetzt Daten empfangen
  while (UCSR0A | (1 << RXC0))
  {
    //Daten empfangen
  }
  data = UDR0;
  return data;
}
void sendeString( char* text )
{
  while( *text )
  sendenByte( *text++ );
}

[Uwe (de0508)]

Hallo,

hast Du dir mal die MÜHE gemacht und das Datenblatt "gegen" deinen Code 
abgeglichen, um zu verstehen was da eigentlich passiert ?

Nicht einfach probieren, sondern alles 1 zu 1 im Datenblatt nachlesen, 
verstehen und auf deiner Checkliste abhaken !

Also was und wie bewirkt das Bit RXCIE0 in UCSR0B, wenn es 1 ist ?