Hallo Bääääär,
danke für's abtippen. Bei Arexx gibt es nämlich immer noch keinen Code.

Im übrigen gibt es beim Empfang von Daten einen kleinen Schönheitsfehler mit evl. fatalen Folgen.
(Ich beziehe mich hier auf deine Funktionsnamen und nicht die aus Band II zum Asuro)
Wie stellt die Funktion RS232_receive() fest, dass der Buffer leer ist? Klar, mit "if (ReadPointer0 == ReadPointer1)"
Aber was passiert im Empfangs-Interrupt SIGNAL (SIG_UART_RECV)?
Dort wird der ReadPointer0 gandenlos mit ++ erhöht wenn ein Zeichen ankommt. "ReadBuffer[ReadPointer0++] = UDR;" (Natürlich wieder auf 0 wenn er zu groß wird.)
Wenn man nun genau so viele Zeichen empfängt wie der RX-Buffer groß ist, steht der ReadPointer0 also wieder an der gleichen Position wie der ReadPointer1.
Und was nun? Da ist doch der Buffer leer sagt die RS232_receive()-Funktion!!!


Wenn ich in deinem Code den auskommentierten #include wieder aufnehme und ein #define für F_CPU anlege und ein kleines main so wie:
int main (void)
{
while (1);
return 0;
}
reinschreibe, kann ich fehlerfrei übersetzen.
Code:
/////////////////////////////////////////////////////////////////////
// Arios: Serial Interface functions                               //
/////////////////////////////////////////////////////////////////////
// Author: Johannes Neumann                                        //
// Date of completion: **.**.****                                  //
/////////////////////////////////////////////////////////////////////

#define	F_CPU 8000000

// Defines //////////////////////////////////////////////////////////

#include <avr/interrupt.h>
#include <avr/io.h>
#include <avr/signal.h>
#include <string.h>
#define cReadBufferSize 32
#define cWriteBufferSize 512
#define cBlockung 1
#define cNonBlocking 0
#define cTXComplete 1;
#define cTXNotComplete 0;

// Variables ////////////////////////////////////////////////////////

volatile unsigned int TXComplete;
volatile unsigned int WritePointer0 = 0, WritePointer1 = 0;
volatile unsigned int ReadPointer0 = 0, ReadPointer1 = 0;
volatile unsigned char ReadBuffer[cReadBufferSize];
volatile unsigned char WriteBuffer[cWriteBufferSize];

// Init /////////////////////////////////////////////////////////////
void RS232_init(long unsigned int baudrate) {
   UCSRA = 0x00;
   UCSRB = (1 << RXCIE) | (1 << RXEN);
   UCSRC = (1 << UCSZ1) | (1 << UCSZ0) | (1 << URSEL);
   UBRRH = (((F_CPU/baudrate) >> 4) - 1) >> 8;
   UBRRL = (((F_CPU/baudrate) >> 4) - 1) & 0xFF;
   TXComplete = cTXComplete;
}


// Send /////////////////////////////////////////////////////////////
int RS232_send(char *c, int blocking) {
   int i;
   for (i=0; i< strlen(c);i++) {
      if ((cWriteBufferSize + WritePointer1 - WritePointer0) % cWriteBufferSize > (cWriteBufferSize - 2)) {
         if (blocking) {
            while((cWriteBufferSize + WritePointer1 - WritePointer0) % cWriteBufferSize > (cWriteBufferSize - 2));
         }
         else
         return i;
      }
      TXComplete = cTXComplete;
      asm("cli");
      WriteBuffer[WritePointer1++] = c[i];
      if (WritePointer1 > cWriteBufferSize - 1) WritePointer1 = 0;
      asm("sei");
      UCSRB = (1<<TXEN) | (1<<UDRIE);
   }
   return i;
}


// Receive //////////////////////////////////////////////////////////
int RS232_receive(char *c, int length, int blocking) {
   int i;
   for (i=0; i<length; i++) {
      if (ReadPointer0 == ReadPointer1) {
         if (blocking) while(ReadPointer0 == ReadPointer1);
         else return i;
      }
      c[i] = ReadBuffer[ReadPointer1++];
      if (ReadPointer1 > cReadBufferSize - 1) ReadPointer1 = 0;
   }
   return length;
}


// Complete? ////////////////////////////////////////////////////////
int RS232_WritingComplete(void) {
   return TXComplete;
}
 
 
// Count of Bytes in ReadBuffer /////////////////////////////////////
int RS232_GetBytesInReadBuffer(void) {
   return (cReadBufferSize + ReadPointer1-ReadPointer0) % cReadBufferSize;
}


// Count of Bytes in WriteBuffer ////////////////////////////////////
int RS232_GetBytesInWriteBuffer(void) {
   return (cWriteBufferSize + WritePointer1-WritePointer0) % cWriteBufferSize;
}


// Interrupt for Reading ////////////////////////////////////////////
SIGNAL (SIG_UART_RECV) {
   ReadBuffer[ReadPointer0++] = UDR;
   if (ReadPointer0 > cReadBufferSize) ReadPointer0 = 0;
}


// Interrupt for writing Data into UDR //////////////////////////////
SIGNAL (SIG_UART_DATA) {
   UDR = WriteBuffer[WritePointer0++];
   if (WritePointer0 < cWriteBufferSize - 1) WritePointer0 = 0;
   if (WritePointer0 == WritePointer1) UCSRB = (1<<TXEN) | (1<<TXCIE);
}


// Interrupt for setting Complete-Flag //////////////////////////////
SIGNAL (SIG_UART_TRANS) {
   UCSRB = (1<<RXCIE) | (1<<RXEN);
   TXComplete = cTXComplete;
}

int main (void)
{
   while (1);
   return 0;
}
Hast du im Makefile das
SRC += asuro.c
auskommentiert? Ist bei mir aber egal. Es geht in beiden Fällen.