Eigenbau-Ringbuffer: Holy oder Crap?

[Stephan (Gast)]

Hallo!

Nebenstehend mein UART-Ringbuffer, mit dem ich zu verhindern versuche, 
dass bei rascher Folge zweier Stringzeilen die eine während der 
Bearbeitung der vorherigen verlorengeht.
-die ISR schreibt stets das neu angekommene Zeichen hinter das letzte 
Zeichen des UART-Strings
-die Ausleseschleife nimmt immer wieder das erste Zeichen des 
UART-Strings, kopiert es in den neuen Nutzstring und verschiebt den 
gesamten UART-String um eine Stelle nach vorn, solange, bis ein \r das 
Ende einer Stringzeile anzeigt.

char nutzstring[100];

void ausleseschleife(void)
{
int i;
int stelle;

while (uart1_str_count != 0 && stringfertig == 0)
{      
  nutzstring[stelle] = uart1_string[0]; 
    
  for ( i=0;i<=100;i++)
  {
    uart1_string[i] = uart1_string[i+1];
  }
  if (nutzstring[stelle] == '\r')
  {
    nutzstring[stelle] = '\0';
    stringfertig = 1;
  }
  uart1_str_count--;
  stelle++;
}  

}

ISR (USART1_RX_vect)    
{
unsigned char nextChar;
nextChar = UDR0;
  if (nextChar != '\n')
  {
    uart1_string[uart1_str_count] = nextChar;  
    uart1_str_count++;
  }
}

Es klappt wunderbar- nur übersehe ich vllt irgendwas?

[Eddy C. (chrisi)]

>Es klappt wunderbar-

So what?

>nur übersehe ich vllt irgendwas?

Was würdest Du denn gerne übersehen?

Heidernei, einen Ringpuffer baut man nicht, indem man die Daten im Kreis 
kopiert, sondern einen Lese- und einen Schreibzeiger implementiert, 
welche am Pufferende auf Pufferanfang zurück gestellt werden. So ist es 
definitiv Crap :-) Sieht irgendwie nach einer Mischung aus Stack und 
FIFO aus, gewürzt mit memcpy...

[Simon K. (simon)]

Das was du gepostet hast, ist "crap". Das lässt sich nicht mal 
kompilieren.

Auf die Schnelle sehe ich aber auch nicht, wo da jetzt der Ringbuffer 
ist.

Eine entsprechende Abstraktion des Puffers fehlt auch. Schon mal 
vorhandene Ringbuffer-Implementierungen angeschaut, wie es dort gemacht 
wird?

[Kan a. (Firma: Basta) (kanasta)]

Übelster Crap. Meine Augen schmerzen immer noch...

[Uwe (de0508)]

Hallo,

ich sehe da keinen UART-Ringbuffer !

Man hat immer einen Schreib- und einen Lesezeiger.

In einer einfachen Abbildung des Ringbuffer ist dieser leer, wenn 
(Schreibzeiger == Lesezeiger) ist.

Dem Zufolge ist der Ringbuffer voll, wenn (UEBERLAUF(Schreibzeiger, 
RINGBUFFER_SIZE) == Lesezeiger) ist.

Hier noch die Definition des Macros:

#define UEBERLAUF( x, max )  x = ++x >= max ? 0 : x

Man benötigt also drei Funktionen:
a) ist ein Zeichen im Ringpuffer ? (Hauptprogramm)
b) Lese ein Zeichen aus dem Ringpuffer. (Hauptprogramm)
c) Schreibe ein Zeichen in den Ringpuffer, das macht dann die ISR.

---

Dein Code ist nicht vollständig, da

uart1_string[]

 nirgendwo definiert ist!

Ich würde ihn als

#define RINGBUFFER_SIZE 32
volatile char uart1_string[RINGBUFFER_SIZE];

anlegen.

Stephan schrieb:
> ISR (USART1_RX_vect)
> {
> unsigned char nextChar;
> nextChar = UDR0;
>   if (nextChar != '\n')
>   {
>     uart1_string[uart1_str_count] = nextChar;
>     uart1_str_count++;
>   }
> }


Link

Hier findet man solch einen Ringpuffer:

[1] Beitrag "Software UART mit FIFO"

[Eddy C. (chrisi)]

Also hier mal eine Version, die das macht das Du evtl. wolltest:

#define BUFSIZE  80
volatile int Put = 0;
volatile int Get = 0;
char Buffer[BUFSIZE];

ISR (USART1_RX_vect)    
{
    Buffer[Put++] = UDR0;
    if (Put == BUFSIZE)
        Put = 0;
}

char ReadChar(void)
{
    // Wait for a character
    while (Put == Get)
        ;
    // Read it from the holy buffer
    char Char = Buffer[Get++];
    if (Get == BUFSIZE)
        Get = 0;
}

void ReadString(char *String)
{
    while (1)
    {
        char Char = ReadChar();
        if (Char == '\n')
            break;
        *String++ = Char;
    }
    // Terminate string
    *String = 0;
}

[Simon K. (simon)]

@Eddy Current: Bei dir fehlt aber schon mal die Abfrage, ob der Puffer 
voll ist :-)

EDIT: Vergiss es, das ist ja gar kein Ringbuffer (hast du aber auch 
nicht behauptet).

EDIT2: Aber so richtig was sinnvolles scheint mir das auch nicht zu 
sein. Das Stückchen Code erzeugt eine gefährliche 
speichervollschreibende Endlosschleife, wenn kein '\n' im Buffer steht.

Baaad baad programming! Ganz ganz übel.

[Eddy C. (chrisi)]

Simon: Das ist ein Ringpuffer. Ich wollte nicht das Funktionsprinzip 
durch Fehlerbehandlung oder schlaue Makros verbergen. Eine verbesserte 
Version von ReadString wäre:

void ReadString(char *String,int MaxLen)
{
    int Len = 0;
    while (1)
    {
        char Char = ReadChar();
        if (Char == '\n')
            break;
        if (Len < MaxLen)
            String[Len++] = Char;
    }
    // Terminate string
    String[Len] = 0;
}

[Stephan (Gast)]

Okay, verstanden. Vielen dank! Bildlich gefiel mir meine Vorstellung 
eines Ringbuffers aber besser.
Und, wohlgemerkt, er funktioniert tadellos!
Werd trotzdem weiter in Richtung etabliertem Ringbuffer arbeiten.

[Stephan (Gast)]

Hallo!
Ich versuche nun den den FIFO- Ringbuffer aus dem Artikel 
http://www.mikrocontroller.net/articles/FIFO
zu verwenden.

#define BUFFER_SIZE 16 // muss 2^n betragen (8, 16, 32, 64 ...)
#define BUFFER_MASK (BUFFER_SIZE-1) // Klammern auf keinen Fall 
vergessen

struct Buffer {
  uint8_t data[BUFFER_SIZE];
  uint8_t read; // zeigt auf das Feld mit dem ältesten Inhalt
  uint8_t write; // zeigt immer auf leeres Feld
} buffer = {{}, 0, 0};

uint8_t BufferIn(uint8_t byte)
{
  uint8_t next = ((buffer.write + 1) & BUFFER_MASK);
  if (buffer.read == next)
    return FAIL;
  buffer.data[buffer.write] = byte;
  // buffer.data[buffer.write & BUFFER_MASK] = byte; // absolut Sicher
  buffer.write = next;
  return SUCCESS;
}

uint8_t BufferOut(uint8_t *pByte)
{
  if (buffer.read == buffer.write)
    return FAIL;
  *pByte = buffer.data[buffer.read];
  buffer.read = (buffer.read+1) & BUFFER_MASK;
  return SUCCESS;
}

Immerzu kommt die Fehlermeldung, er erwarte ,/;/oder attributes vor 
BufferOut oder BufferIn. Ich vermute nicht, dass der Fehler im Code 
liegt, wohl eher in einer meiner Header- Dateien- weiß wer Rat?