FIFO-Buffer für Strings

[Andreas M. (chillymu)]

Hallo Leute,

ich versuche gerade einen Fifo- Buffer für mein Uart hin zubekommen wo
immer ein ganzer string gespeichert werden soll.

Das Speichern des Befehls funktioniert schon sehr gut nur das abfragen
mittels Pointer habe ich noch nicht so ganz im Griff.

Dabei habe ich mir als Beispiel den 2^n-Ringbuffer aus diesem Artikel
genommen: http://www.mikrocontroller.net/articles/FIFO

Volgendes habe ich gemacht:

Struktur für den Fifo-Buffer:

#define UART_FIFO_CMD_LEN 256   // länge eines Strings
#define UART_FIFO_ANZ 128       // muss 2^n betragen (8, 16, 32, 64 ...)
#define FIFO_MASK (UART_FIFO_ANZ - 1) // Klammern auf keinen Fall
vergessen

struct fifo_buffer {
  char data[UART_FIFO_ANZ][UART_FIFO_CMD_LEN];
  unsigned char read; // zeigt auf das Feld mit dem ältesten Inhalt
  unsigned char write; // zeigt immer auf leeres Feld
} uart_fifo = {{}, 0, 0};

Funktion zum speichern des Commandos:

unsigned char Topt_mod_uart_FifoIn(char *pcCom){

  unsigned int next;

  next = ((uart_fifo.write + 1) & FIFO_MASK);
  if (uart_fifo.read == next)
    return 1;
  strcpy(uart_fifo.data[uart_fifo.write & FIFO_MASK],pcCom);
  uart_fifo.write = next;
  return NOERR;
}

Funktion zum ausgeben des ersten Commandos:

Eigentlich möchte ich das ich die Funktion aufrufe und dann mit dem
Pointer pcComFifo weiter arbeiten kann.

unsigned char Topt_mod_uart_FifoOut(char *pcComFifo)
{
  if (uart_fifo.read == uart_fifo.write)
    return 60;
  // ergibt nicht das was ich will
  *pcComFifo = uart_fifo.data[uart_fifo.read];
  uart_fifo.read = (uart_fifo.read+1) & FIFO_MASK;
  return NOERR;
}

Habt Ihr da vielleicht eine Idee. Ich glaub ich hab da einen Denkfehler.
Wie würde ich das mit der Pointerübergabe denn realisieren?

Gruß Andreas

[JLes (Gast)]

Andreas Müller schrieb:
> unsigned char Topt_mod_uart_FifoOut(char *pcComFifo)
> {
>   if (uart_fifo.read == uart_fifo.write)
>     return 60;
>   // ergibt nicht das was ich will
>   *pcComFifo = uart_fifo.data[uart_fifo.read];
>   uart_fifo.read = (uart_fifo.read+1) & FIFO_MASK;
>   return NOERR;
> }

char **pcComFifo im Parameter wäre korrekter.

[Andreas M. (chillymu)]

Hi Leute,

der Tip war super. Jetzt funktioniert es.

Funktionsaufruf:

unsigned char Topt_mod_usb_interpreter_get_uart(char *pcParm){
    char *pcComFifo;
    Topt_mod_uart_FifoOut(&pcComFifo);
    return NOERR;
}

FIFO-Funktionen:

#define UART_FIFO_CMD_LEN 256   // länge eines Strings
#define UART_FIFO_ANZ 128       // muss 2^n betragen (8, 16, 32, 64 ...)
#define FIFO_MASK (UART_FIFO_ANZ - 1) // Klammern auf keinen Fall
vergessen

struct fifo_buffer {
  char data[UART_FIFO_ANZ][UART_FIFO_CMD_LEN];
  unsigned char read; // zeigt auf das Feld mit dem ältesten Inhalt
  unsigned char write; // zeigt immer auf leeres Feld
} uart_fifo = {{}, 0, 0};


unsigned char Topt_mod_uart_FifoIn(char *pcCom){

  unsigned int next;

  next = ((uart_fifo.write + 1) & FIFO_MASK);
  if (uart_fifo.read == next)
    return 1;
  strcpy(uart_fifo.data[uart_fifo.write & FIFO_MASK],pcCom);
  uart_fifo.write = next;
  return NOERR;
}

unsigned char Topt_mod_uart_FifoOut(char **pcComFifo)
{
  if (uart_fifo.read == uart_fifo.write)
    return 1;
  *pcComFifo = uart_fifo.data[uart_fifo.read];

  uart_fifo.read = (uart_fifo.read+1) & FIFO_MASK;
  return 0;
}

JLes:
Kannst du mir kurz die Hintergründe des doppelstern beschreiben?
Das wäre mir für die Zukunft sehr geholfen.

Gruß Andreas

[Karl H. (kbuchegg)]

Andreas Müller schrieb:

> Kannst du mir kurz die Hintergründe des doppelstern beschreiben?
> Das wäre mir für die Zukunft sehr geholfen.


In C werden (mit Ausnahme von Arrays) Argumente an eine Funktion immer 
so übergeben, dass die Funktion eine Kopie des Wertes bekommt.

void foo( int j )
{
  j = 8;
}

int main()
{
  int i;

  i = 5;

  foo( i );
}

Wenn von main aus foo aufgerufen wird, so bekommt foo eine Kopie des 
Wertes von i, abgelegt in er Variablen j. Wenn daher foo j verändert, 
dann macht es das nur lokal, i ist davon nicht betroffen.

Nur manchmal möchte man genau das nicht. Man möchte haben, dass eine 
Funktion eine Variable beim Aufrufer ändern kann. Was tun?
Nun in diesem Fall, darf man logischerweise keine Kopie des aktuellen 
Wertes an die Funktion übergeben, sondern man übergibt die Adresse der 
Variablen (die natürlich ebenfalls als Kopie übergeben wird). Die 
Funktion kann dann über diese Speicheradresse, direkt auf die Variable 
des Aufrufers zugreifen

void foo( int* j )
{
  *j = 8;
}

int main()
{
  int i;

  i = 5;

  foo( &i );
}

Jetzt kann foo, über den Pointer, direkt auf i in main zugreifen und es 
verändern.

Das allgemeine Schema sieht daher so aus.
Sei T irgendein Datentyp, dann ermöglicht mir

void foo( T* argument )
{
  *argument = ....

dass die Funktion eine Variable vom Datentyp T beim Aufrufer ändern kann

  T eine_Variable;

  foo( & eine_Variable );

T kann jetzt irgendein Datentyp sein. Zb. auch ein char*
Setzt du für T char* ein, so erhältst du

void foo( char** argument )
{
 ...
}

  char* eine_Variable;

  foo( & eine_Variable );

Hat denn dein C-Buch gar nichts zum Thema Argument-Passing an Funktionen 
zu sagen?

[D. I. (Gast)]

Das ist ein Pointer auf einen Pointer

[JLes (Gast)]

Andreas Müller schrieb:
> Kannst du mir kurz die Hintergründe des doppelstern beschreiben?

Gerne.

Wenn der Parameter so aussieht:

char *pcComFifo

referenziert er über den Pointer ein Char-Zeichen. Du benötigst aber 
einen String, richtig? Du versuchst den String mit der Zeile

*pcComFifo = uart_fifo.data[uart_fifo.read];

zurückzugeben. Formal gesehen (ohne Rücksicht auf Parametertyp), ist 
diese Zeile ganz korrekt. Der Zeiger auf aktuelle zu lesende Zeile wird 
in den Speicher geschrieben, der über den Parameter pcComFifo 
referenziert wird. In der alten Version wird ein Zeichen (also 1 Byte) 
referenziert, und 1 Byte von... ich weiss dein Memory-Model nicht, aber 
angenommen für Win32 ist es 4-Byte-Adresse... also von 4 Bytes wird nur 
1 übertragen.

In der Funktion Topt_mod_usb_interpreter_get_uart hast du den String 
richtig deklariert: char *pcComFifo. Das ist ein Zeiger auf die 
Zeichen(kette). Wenn Du diesen als Referenz in andere Funktion 
übertragst, wird ein Zeiger auf dein Speicherplatz namens pcComFifo 
übertragen, der "Zeiger auf den Zeiger auf die Zeichen" heißt. Daher 
zwei Sterne beim Parameter.

[Andreas M. (chillymu)]

Also ich muss ja mal was loswerden. Das Forum ist einfach nur spitze und 
ihr seit spitze. Jetzt hab ich das auch verstanden mit dem Pointer auf 
einen Pointer.

Ihr seit echt klasse. Großes Lob und Danke für die Hilfe.

Gruß Andreas