UART, Testprogramm aus Buch läuft nicht

/**************************************************************

*                                                              *

*                         UART.c                                *

*                                                              *

***************************************************************/

/* Include-Dateien   

   -----------------*/

#include <io8515.h>    // Register Definition fuer AT90S8515

#include <ina90.h>     // Intrinsic Funktionen fuer ICCA90 

/* UCR - UART Control Register: Bit Definitionen 

   -----------------------------------------------------------*/

#define     RXCIE    0x80    // Bit 7 

#define     TXCIE    0x40    // Bit 6 

#define     UDRIE    0x20    // Bit 5 

#define     RXEN     0x10    // Bit 4 

#define     TXEN     0x08    // Bit 3 

#define     CHR9     0x04    // Bit 2 

#define     RXB8     0x02    // Bit 1 

#define     TXB8     0x01    // Bit 0 

/* USR - UART Status Register: Bit Definitionen 

    ---------------------------------------------------------*/

#define     RXC     0x80    // Bit 7 

#define     TXC     0x40    // Bit 6 

#define     UDRE    0x20    // Bit 5 

#define     FE      0x10    // Bit 4 

#define     OVR     0x08    // Bit 3 

/* UBRR - UART Baudrate Register: Baud Definitionen fuer 4MHz

    ---------------------------------------------------------*/

#define     BAUD_1200     208

#define     BAUD_2400     103

#define     BAUD_9600     25

#define     BAUD_19200    12

/* UART Daten-Puffer Definitionen 

    ------------------------------*/

#define BUFFER_SIZE     8     // Modulo 2 Groesse: nur 2,4,8,16,32 Bytes 

#define BUFFER_MASK     (BUFFER_SIZE-1)

/* Allgemeine typ-Definitionen 

    -----------------------------------------------------------*/

typedef enum{ FALSE=0, TRUE=1} Boolean_t ;

typedef struct{ unsigned char UartData[ BUFFER_SIZE ];

                unsigned char NumberOfBytes;

                unsigned char UartStatus; } Uart_t; 

/* Static Variables 

   -------------------*/

static unsigned char                RxBuf[ BUFFER_SIZE ];

static volatile unsigned char       RxProducer;  // Empfang: Int-Service ist der Producer

static volatile unsigned char       RxConsumer;  // Empfang: Hauptprogramm ist Consumer

static unsigned char                TxBuf[ BUFFER_SIZE ];

static volatile unsigned char       TxProducer;  // Senden: Hauptprogramm ist der Producer

static volatile unsigned char       TxConsumer;  // Senden: Int-Service ist Consumer

/* Funktion-Prototypen

   ----------------------------*/

void InitUart( unsigned char baudrate );

Boolean_t ReceiveData( Uart_t * Data );

Boolean_t TransmitData( Uart_t * Data );

void Delay( void ); 

/* Input Pins, Port B:               sfrb PINB    = 0x16; 

   Data Direction Register, Port B:  sfrb DDRB    = 0x17; 

   Data Register, Port B:            sfrb PORTB   = 0x18; */

void Delay( void )

{

  unsigned int i= 0x7FFF;

  while(--i);

}

/* Main - ein einfaches Anwendungsbeispiel fuer UART und Timer 

   -------------------------------------------------------------*/

void C_task main( void )

{

    Uart_t UartData;

    DDRB  = 0xFF ; // Konfiguriert Port B als Ausgang

    PORTB = 0xAA;

    InitUart( BAUD_9600 );     // Baudrate = 9600 Baud bei 4MHz Quarz

    _SEI();                      // Freigabe aller Interrupts => Enable UART Interrupts 

    for( ;; )                  // Endlos-Schleife 

    {

        if( ReceiveData( & UartData ) )

        {  

          TransmitData( & UartData );     // Echo der empfangenen Bytes

         }

        PORTB++; // led switch

        Delay();

    }

}

/* Initialisierung der UART 

    ------------------------------*/

void InitUart( unsigned char baudrate )

{

    UBRR = baudrate;               // Baudrate setzen 

                                  // Freigabe der UART Interrupts

    UCR =  TXEN | RXEN | RXCIE;   // ==> Senden/Empfangen/Empf.INT

    RxConsumer     = 0;            // Ruecksetzen der Puffer-Index 

    RxProducer     = 0;

    TxConsumer     = 0;

    TxProducer     = 0;

}

/*  Empfangs-Interrupt Handler

    --------------------------- */

interrupt [UART_RX_vect] void UartRxIntHandler( void )

{

    unsigned char data;

    data = UDR;                 // Lesen der Empfangsdaten 

    RxBuf[RxProducer] = data;   // Empfangenes Byte in Puffer ablegen  

    RxProducer++;               // Bufferindex setzen

    RxProducer &=BUFFER_MASK;   // Index begrenzen und evtl. auf Puffer-Anfang

    if (RxProducer == RxConsumer )

    {

        // Fehler! Ueberlauf Empfangspuffer 

    }

}

/*  Sende-Interrupt Handler

    --------------------------- */

interrupt [UART_UDRE_vect] void UART_TX_interrupt( void )

{

    // Test ob noch nicht fertig mit Senden  

    if ( TxConsumer != TxProducer )

    {

        ++TxConsumer;               // Pufferindex aktualisieren 

        TxConsumer &=BUFFER_MASK;   // Index begrenzen und evtl. auf Puffer-Anfang

        UDR = TxBuf[TxConsumer];    // Uebergabe eines Bytes 

      }

    else

    {

        UCR &= ~UDRIE; // Disable UDRE interrupt

    }

} 

/* UART Empfangsfunktion 

   --------------------- */

Boolean_t ReceiveData( Uart_t * Data )

{

    unsigned char i=0;

    // Schleife zur Uebergabe der empfangenen Daten

    while (( RxConsumer != RxProducer ) && ( i < BUFFER_SIZE ) ) 

    {

       Data->UartData[i++] = RxBuf[RxConsumer++];

       RxConsumer &=BUFFER_MASK;   // Consumer-Index begrenzen und evtl. auf Puffer-Anfang                          

    }

    Data->NumberOfBytes = i ;

    if( i ) return TRUE ;

     else return FALSE ;

}

/* Sendefunktion 

   --------------------- */

Boolean_t TransmitData( Uart_t * Data )

{

    unsigned char i=0;

    while (( i < Data->NumberOfBytes ) && ( i < BUFFER_SIZE ) )// Uebergabe Empfangsdaten 

    {

       TxBuf[TxProducer++] = Data->UartData[i++] ;

       TxProducer &=BUFFER_MASK;   // Producer-Index begrenzen und evtl. auf Puffer-Anfang                          

    }

    UDR = TxBuf[TxConsumer];        // Senden Anstossen

    ++TxConsumer; 

    TxConsumer &=BUFFER_MASK;   // Consumer-Index begrenzen

    UCR |=  UDRIE ;

    Data->NumberOfBytes = 0;

    return TRUE ;

}