Problem mit FIFO

[Philipp M. (lord-maricek)]

Moin,

ich versuche Daten, die vom GPS und XBee an meinen Atmega1284P gesendet 
werden, über das XBee zurückzusenden. Dafür habe ich von dieser Homepage 
http://www.mikrocontroller.net/articles/FIFO den 2^n-Ringbuffer benutzt.
Das hier ist die FIFO Datei: Es ist 3x das gleiche, nur dass es einmal 
XI ( empfangene XBee Daten), XO (XBee Daten zum senden) und GPS für die 
empfangenden GPS Daten.

#include "fifo.h"

//OUT_Buffer
struct XO_Buffer {
  uint8_t data[BUFFER_SIZE];
  uint8_t read;
  uint8_t write; 
} XO_buffer = {{}, 0, 0}; 

uint8_t XO_BufferIn(uint8_t byte)
{
  uint8_t next = ((XO_buffer.write + 1) & BUFFER_MASK);
  if (XO_buffer.read == next)
    return FAIL;
  XO_buffer.data[XO_buffer.write] = byte;
  XO_buffer.write = next;
  UCSR1A |= (1<<UDRIE1);
  return SUCCESS;
}
 
uint8_t XO_BufferOut(uint8_t *pByte)
{
  if (XO_buffer.read == XO_buffer.write)
  {
    UCSR1A &= ~(1<<UDRIE1);
    return FAIL;
  }
  *pByte = XO_buffer.data[XO_buffer.read];
  XO_buffer.read = (XO_buffer.read+1) & BUFFER_MASK;
  return SUCCESS;
}


//IN_Buffer
struct XI_Buffer {
  uint8_t data[BUFFER_SIZE];
  uint8_t read;
  uint8_t write; 
} XI_buffer = {{}, 0, 0};
 
uint8_t XI_BufferIn(uint8_t byte)
{
  uint8_t next = ((XI_buffer.write + 1) & BUFFER_MASK);
  if (XI_buffer.read == next)
    return FAIL;
  XI_buffer.data[XI_buffer.write] = byte;
  XI_buffer.write = next;
  return SUCCESS;
}
 
uint8_t XI_BufferOut(uint8_t *pByte)
{
  if (XI_buffer.read == XI_buffer.write)
    return FAIL;
  *pByte = XI_buffer.data[XI_buffer.read];
  XI_buffer.read = (XI_buffer.read+1) & BUFFER_MASK;
  return SUCCESS;
}


//GPS_Buffer
struct GPS_Buffer {
  uint8_t data[BUFFER_SIZE];
  uint8_t read;
  uint8_t write; 
} GPS_buffer = {{}, 0, 0};
 
uint8_t GPS_BufferIn(uint8_t byte)
{
  uint8_t next = ((GPS_buffer.write + 1) & BUFFER_MASK);
  if (GPS_buffer.read == next)
    return FAIL;
  GPS_buffer.data[GPS_buffer.write] = byte;
  GPS_buffer.write = next;
  return SUCCESS;
}
 
uint8_t GPS_BufferOut(uint8_t *pByte)
{
  if (GPS_buffer.read == GPS_buffer.write)
    return FAIL;
  *pByte = GPS_buffer.data[GPS_buffer.read];
  GPS_buffer.read = (GPS_buffer.read+1) & BUFFER_MASK;
  return SUCCESS;
}

Erstes Problem: In den FIFO Funktionen für XO wird das UDRE Interrupt 
Bit gesetzt und wieder gelöscht, wenn keine Daten mehr drin sind. Aber 
das UDRE Interreput wird nie ausgelöst.

Anderes Problem. Ich habe versucht, die Daten vom XBee ohne FIFO zurück 
zusenden. Hier ist die Main Funktion:

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

#include "defines.h"
#include "fifo.h"
#include "uarts.h"
#include "steer.h"

int main(void)
{
  uint8_t tmp_byte = 0x00;
  DDRC = 0xff;
  PORTC |= 0xff;
  delay_ms(1000);
  PORTC &= ~PORTC;

  uart_init();
  sei();
  while(1)
  {
    
    if(GPS_BufferOut(&tmp_byte))
    {
      //XO_BufferIn(tmp_byte);
    }
    if(XI_BufferOut(&tmp_byte))
    {
      //XO_BufferIn(tmp_byte);
                        uart_putc(tmp_byte);
    }  
  }
  return 0;
}

//USART Interrupts
//GPS
ISR(USART0_RX_vect)
{
  //uart_putc('G');
  uint8_t tmp = UDR0;
  if(!GPS_BufferIn(tmp))
    PORTC = 0xff;
}

//XBee
ISR(USART1_RX_vect)
{
  //uart_putc('X');
  uint8_t tmp = UDR1;
  if(!XI_BufferIn(tmp))
    PORTC = 0xff;
}

ISR(USART1_UDRE_vect)
{
  //uart_putc('O');
  uint8_t tmp;
  if(XO_BufferOut(&tmp))
    UDR1 = tmp;
}

Aber das Byte wird nach dem abfragen nicht gelöscht, und sobald man auch 
nur einen Buchstaben/Zahl sendet, bekommt man die gleich unendlich mal 
zurück gesendet. Ich kann meinen Fehler nicht finden. Vielleicht findet 
einer von den.

MfG
Philipp