Handshake problem

danke Rahul,
mit deine Hilfe bin ich ein schritte weiter gekommen aber es ist noch 
nicht was ich genau wollte. das programm liefert mir nur ein byte 
zurrück und zwar das letzte eingegebene byte. Ich will gerne alle byte 
die ich eingegeben habe wieder zurrückt haben und in die selbe reihen 
folge (FIFO).
kann jemand mir sagen wie ich das machen kann.
danke
MFG
jano

Danke Karl für die Hinweisen.
ich habe mein code nochmal geschrieben und ich dachte es sollte 
functionnieren
aber es geht immer nicht.
bitte schauen sie meine code und helfen sie mir mein programm im reihe 
zu kriegen bitte.
MFG
jano


//
// Datei uart.c
// MCU: Atmega16
//
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>


  /* ATmega with one USART */
 #define ATMEGA_USART
 #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV
 #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA
 #define UART0_STATUS   UCSRA
 #define UART0_CONTROL  UCSRB
 #define UART0_DATA     UDR
 #define UART0_UDRIE    UDRIE

 /*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 10
 #endif

 /*high byte error return code of uart_getc()*/
 #define UART_NO_DATA     0x0100

// CHECK F_CPU WITH HARDWARE OSZILLATOR SETTING !!!!
#define F_CPU 1000000UL
#define UART_BAUD 9600

/*
 *  module global variables
 */
int g_idx;
int p_idx;
int MAX_BUFFER_SIZE;
MAX_BUFFER_SIZE=UART_TX_BUFFER_SIZE;
unsigned char Buf[UART_TX_BUFFER_SIZE]; //Empfang Buffer
unsigned char TBuf[UART_TX_BUFFER_SIZE];// Sende Buffer
int tmp = 0;
unsigned char c;

void uart_init(void);
unsigned int uart_getdata(void);
//unsigned char uart_getc(void);
void uart_putdata(unsigned char c);
//int uart_putc(unsigned char c);
void uart_puts (char *s);

int main(void)
{
   unsigned char c;

   DDRD = 0XFF;     // PORT D als Ausgang
   PORTD = 0x08;   // 4.Pin des PORTD eischalten um das CTS anzusprechen 
(empfangt Bedingung für die controller)

   uart_init();
   sei();
   uart_puts("hello world!\r\n\r\n");

   while(1)
   {
      // Poll
      c = uart_getdata();

      // Funny conversion

     /************************************************************
     This converion ist only use to convert the alphabetic letter
     and they will be return als echo to the screen
     ************************************************************/

      //if (c >= 'a' && c <= 'z')
       //  c += 'A' - 'a';
      //else if (c >= 'A' && c <= 'Z')
        // c += 'a' - 'A';

      // Echo
      uart_putdata(c);
   }

   return 0;
}

void uart_init(void)

/******************************************************************
 Function: Uart_init()
 Purpose: Initialise UART and set baudrate
 Input: baudrate
 Returns: none
 ******************************************************************/

{


  UCSRB |= (1<<TXEN) |(1<<RXEN) |(1<<RXCIE);  // tx/rx enable
    UCSRC |= (1<<URSEL)|(3<<UCSZ0); // Asynchron 8N1

#if F_CPU < 2000000UL && defined(U2X)
    UCSRA |= (1<<U2X);   /* improve baud rate error by using 2x clk */
    UBRRL = (F_CPU / (8UL * UART_BAUD)) - 1;
#else
    UBRRL = (F_CPU / (16UL * UART_BAUD)) - 1;
#endif
}


ISR(USART_RXC_vect)
{
  c = UDR;
}


ISR(USART_UDRE_vect)
{
 p_idx = tmp;
 if (p_idx <= g_idx)
 {
   UDR = TBuf[p_idx];
   tmp++;
 }
 else
 {
   UCSRB &= ~UDRIE;
 }
 return;
}

void uart_putdata(unsigned char c)
{
   int n = g_idx;
   g_idx = 0;

   while (g_idx == n);  // fertig mit senden
    {
   PORTD = 0x08;     // CTS Pin der controller ist wieder ein: sie kann 
wieder die Daten empfangen
   return;          //  zurrückt zur Hauptprogramm
  }

/***************************************************************
 Die Daten werden im Empfangt Puffer geholt und im Transmitter
  Puffer gespeichert damit das sie werden byte pro byte geholt
  und gesendet
****************************************************************/
  c = Buf[g_idx];
  TBuf[g_idx] = c;
    g_idx++;
    UCSRB |= (1<<UDRIE);

}


unsigned int uart_getdata(void)
{
  g_idx = 0;
  while(g_idx != MAX_BUFFER_SIZE) //Das Empfang Puffer ist nicht voll
  {
    if(c == '\r')                 // letzte zeichen: zurrückt zur 
Hauptprogramm
     {
    return;
   }
  else
   {
    Buf[g_idx] = c; // Zeichen im Empfang puffer laden bis der Puffer 
voll ist
    g_idx++;
   }

  }
   PORTD = 0x04;  // der Puffer ist voll die Controller kann keine daten 
mehr empfangen
   return;       // also CTS ausschalten und RTS freischalten damit der 
Controller kann die daten senden
 }

hallo,
kann jemand mir helfen?
danke

Danke Karl für deine Hilfe,
ich habe noch was zu fragen: wie sieht aus mit dem funktion 
ISR(USART_UDRE_vect) um die Daten zurrückt an der Hyperterminal zu 
schicken.
MFG
Jano

es ist so die zeichen sollen von Tastatur eigegeben und im Puffer der 
Controller gespeichert bis die letzte zeichen die wäre die Enter (cr) 
zeichen oder bis der Puffer voll nach diesem sollte die zeichen von 
Controller zu PC(Hyperterminal)geschickt. deswegen in deinem code 
verstehe ich nicht die Linereceived und die die function:

void uart_puts( const char* OutText )
{
  strcpy( TBuf, OutText );

  ... gib die Zeichen aus TBuf Zeichen für Zeichen
      aus. Dies kann zb. mit einer Interruptsteuerung
      passieren. Das erste Zeichen wird hier ausgegeben.
      Wenn es übertragen wurde, wird ein Interrupt ausgelöst,
      welcher zum Aufruf einer ISR führt, in der dann die
      weiteren Zeichen ausgegeben werden.

  ... Als Übung für den Leser absichtlich nicht implementiert, sondern
      die einfachere Variante

  unsigned char i = 0;
  while( TBuf[i] != '\0' )
    usart_putc( TBuf[i] );
}

MFG
Jano