eeprom uart atmega8 was mache ich falsch!

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/pgmspace.h>

#include <util/delay.h>

#ifndef F_CPU

#define F_CPU 4000000UL  //external clock from STK500

#endif

// 9600 baud 

#define UART_BAUD_RATE  9600 

/** Size of the circular receive buffer, must be power of 2 */

#ifndef UART_RX_BUFFER_SIZE

#define UART_RX_BUFFER_SIZE 32

#endif

/** Size of the circular transmit buffer, must be power of 2 */

#ifndef UART_TX_BUFFER_SIZE

#define UART_TX_BUFFER_SIZE 32

#endif

/* test if the size of the circular buffers fits into SRAM */

#if ( (UART_RX_BUFFER_SIZE+UART_TX_BUFFER_SIZE) >= (RAMEND-0x60 ) )

#error "size of UART_RX_BUFFER_SIZE + UART_TX_BUFFER_SIZE larger than size of SRAM"

#endif

/* 

** high byte error return code of uart_getc()

*/

#define UART_FRAME_ERROR      0x0800     // Framing Error by UART

#define UART_OVERRUN_ERROR    0x0400     // Overrun condition by UART

#define UART_BUFFER_OVERFLOW  0x0200     // receive ringbuffer overflow

#define UART_NO_DATA          0x0100     // no receive data available  

/*

 *  constants and macros

 */

#define UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ((F_CPU)/((UART_BAUD_RATE)*16l)-1)

// size of RX/TX buffers 

#define UART_RX_BUFFER_MASK ( UART_RX_BUFFER_SIZE - 1)

#define UART_TX_BUFFER_MASK ( UART_TX_BUFFER_SIZE - 1)

#if ( UART_RX_BUFFER_SIZE & UART_RX_BUFFER_MASK )

#error RX buffer size is not a power of 2

#endif

#if ( UART_TX_BUFFER_SIZE & UART_TX_BUFFER_MASK )

#error TX buffer size is not a power of 2

#endif

#define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV

 #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA

 #define UART0_STATUS   USR

 #define UART0_CONTROL  UCR

 #define UART0_DATA     UDR  

 #define UART0_UDRIE    UDRIE

 //  module global variables

static volatile unsigned char UART_TxBuf[UART_TX_BUFFER_SIZE];

static volatile unsigned char UART_RxBuf[UART_RX_BUFFER_SIZE];

static volatile unsigned char UART_TxHead;

static volatile unsigned char UART_TxTail;

static volatile unsigned char UART_RxHead;

static volatile unsigned char UART_RxTail;

static volatile unsigned char UART_LastRxError;

SIGNAL(UART0_RECEIVE_INTERRUPT)

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

//Function: UART Receive Complete interrupt

//Purpose:  called when the UART has received a character

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

{

    unsigned char tmphead;

    unsigned char data;

    unsigned char usr;

    unsigned char lastRxError;

    /// read UART status register and UART data register 

    usr  = UART0_STATUS;

    data = UART0_DATA;

   //calculate buffer index  

    tmphead = ( UART_RxHead + 1) & UART_RX_BUFFER_MASK;

    if ( tmphead == UART_RxTail ) {

        // error: receive buffer overflow 

        lastRxError = UART_BUFFER_OVERFLOW >> 8;

    }else{

        // store new index 

        UART_RxHead = tmphead;

        // store received data in buffer 

        UART_RxBuf[tmphead] = data;

    }

    UART_LastRxError = lastRxError;   

}

SIGNAL(UART0_TRANSMIT_INTERRUPT)

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

//Function: UART Data Register Empty interrupt

//Purpose:  called when the UART is ready to transmit the next byte

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

{

    unsigned char tmptail;

    if ( UART_TxHead != UART_TxTail) {

        // calculate and store new buffer index

        tmptail = (UART_TxTail + 1) & UART_TX_BUFFER_MASK;

        UART_TxTail = tmptail;

        // get one byte from buffer and write it to UART

        UART0_DATA = UART_TxBuf[tmptail];  // start transmission

    }else{

        // tx buffer empty, disable UDRE interrupt

     UCSRB |= (0<<UDRIE);

        //UART0_CONTROL &= ~_BV(UART0_UDRIE);

    }

}

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

//Function: uart_init()

//Purpose:  initialize UART and set baudrate

//Input:    baudrate using macro UART_BAUD_SELECT()

//Returns:  none

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

void uart_init(unsigned int baudrate)

{

    UART_TxHead = 0;

    UART_TxTail = 0;

    UART_RxHead = 0;

    UART_RxTail = 0;

    UBRRH = (unsigned char)(baudrate>>8);

    UBRRL = (unsigned char) baudrate;

  //Set data frame format: asynchronous mode,no parity, 1 stop bit, 8 bit size

  UCSRC=(1<<URSEL)|(0<<UMSEL)|(0<<UPM1)|(0<<UPM0)|

    (0<<USBS)|(0<<UCSZ2)|(1<<UCSZ1)|(1<<UCSZ0);  

  //Enable Transmitter and Receiver and Interrupt on receive complete

  UCSRB=(1<<RXEN)|(1<<TXEN)|(1<<RXCIE);  

}// uart_init 

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

//Function: uart_putc()

//Purpose:  write byte to ringbuffer for transmitting via UART

//Input:    byte to be transmitted

//Returns:  none          

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

void uart_putc(unsigned char data)

{

    unsigned char tmphead;

    while (!(UCSRA & (1<<UDRE))); // Do nothing until data have been   

                                   //transmited 

    tmphead  = (UART_TxHead + 1) & UART_TX_BUFFER_MASK;

    while ( tmphead == UART_TxTail ){

        ;// wait for free space in buffer 

    }

    UART_TxBuf[tmphead] = data;

    UART_TxHead = tmphead;    

    UART0_DATA = UART_TxBuf[tmphead];  // Put data into Buffer, sends the  

                                       //data

    _delay_ms(10); 

    // enable UDRE interrupt 

    UCSRB |= (1<<UDRIE);

}// uart_putc

/* command sequences im EEPROM (first program Flash, then EEPROM) */ 

unsigned char eeMenue[] EEMEM = { 0x02, 0x21, 0x32, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x9D, 0x2A };

unsigned char eeExit[] EEMEM  = { 0x02, 0x21, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x5C, 0x2A };

unsigned int c, iState;

char cSend;

/* Sends a 19 character command found in EEPROM */

void SendCommand(unsigned int iNo)

{

  unsigned i;  

  for  (i = 19 * iNo; i <= 19 * iNo + 18; i++ )

  {

  cSend = eeprom_read_byte(&eeMenue[i]);

  uart_putc(cSend);

  }

}

int main(void)

{

  PORTD = 0x0C;    // pull ups for key inputs  PortD2 and portD3   

  DDRC = 0x03;     // outputs for LEDs 

  PORTC = 0x03;    /( LEDs off

  /*

   *  Initialize UART library, pass baudrate and AVR cpu clock

   *  with the macro 

   *  UART_BAUD_SELECT() (normal speed mode )

   */

  uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); 

  /*

   * now enable interrupt, since UART library is interrupt controlled

   */

  sei();

  iState = 0;

  for(;;)

    {  

  if (iState != PIND)  /* Key state changed ? */ 

  {

    _delay_ms(50);

    if ((PIND & 0x08) == 0x00)        /* one key */

    {

      PORTC = 1;

      SendCommand(0);

    }

          else

          {

      if ((PIND & 0x0C) == 0x0C)   /* no key */

        PORTC = 3;            

          }

    iState = PIND;

    _delay_ms(2000);  /* dirty "debounce" */ 

  }

    }

    return 0;

}