brauche Hilfe bei Erweiterungen von Fifo-Funktionalitäten

[Anfänger (Gast)]

Hi,

ich bin hier auf einen megacoolen Fifo gestossen:

Quelle: 
http://www.mikrocontroller.net/articles/FIFO#FIFO_mit_C-Pr.C3.A4prozessor

#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;
}

Ich möchte gerne noch zwei Funktionalitäten dazu haben - Fifo leeren und 
Anzahl Elemente im Fifo ausrechnen.

Dazu habe ich mir folgendes ausgedacht:

void BufferClear()
{
    buffer.read = buffer.write = 0;
}

uint8_t BufferAnzahl()
{
    int16_t hilf;
    hilf = buffer.write-buffer.read;
    
    // keine Werte vorhanden:
    if (hilf=0) {
        return (0);
     }
    
    // hilf > 0
    if (hilf>0) {
       return (hilf);
    }
    
    if (hilf<0) {
        return (BUFFER_SIZE-hilf);
    }
}

Bei der clear-Funktion braucht man glaub ich nicht weiter diskutieren - 
so ist sie auf alle Fälle leer. Aber bei der Ermittlung der Anzahl der 
Elemente in dem Fifo bin ich mir unsicher. Ist die Lösung so brauchbar 
mit den drei if-Abfragen - oder gibt es eine einfachere Variante? Ich 
habe die Hilfsvariable extra als int-Variable genommen, die doppelt so 
groß ist, wie die uint8_t-Variable, damit beim Subtrahieren auch ein 
negativer Wert funktioniert. Meint ihr, das das so funktioniert, was ich 
mir ausgedacht hab?

[gonso (Gast)]

Das sieht schon mal brauchbar aus. Aber die Kommentare wie // hilf > 0 
sind total überflüssig.

Nach jedem return fehlt noch ein break, damit die Funktion vorzeitig 
beendet wird.

[Max H. (hartl192)]

Anfänger schrieb:
> oder gibt es eine einfachere Variante?

uint8_t BufferAnzahl()
{
  return (buffer.write - buffer.read) & (BUFFER_SIZE - 1);
}

BUFFER_SIZE muss eine Zweierpotenz mit ganzzahlige Exponenten sein.

gonso schrieb:
> Nach jedem return fehlt noch ein break, damit die Funktion vorzeitig
> beendet wird.
Die Funktion wird durch das return beendet.

[chris (Gast)]

Anfänger schrieb:
> if (hilf=0)

das geht schief.

if (hilf == 0)

gonso schrieb:
> Nach jedem return fehlt noch ein break, damit die Funktion vorzeitig
> beendet wird.

Und das ist Käse. 'return' beendet die Funktion

[Anfänger (Gast)]

Ich finds total lieb von Euch, dass Ihr Euch meinen Quellcodeentwurf 
angeschaut und verbessert habt.

Vielen Dank :-)

[Max H. (hartl192)]

Anfänger schrieb:
> if (hilf<0) {
>         return (BUFFER_SIZE-hilf);
>     }
Das get auch schief: Wenn hilf negativ ist, dann ist BUFFER_SIZE-hilf 
größer als BUFFER_SIZE, z.B. 128 - -6 = 134.

BTW: return ist keine Funktion, die Klammen sind also nicht notwendig.

[Anfänger (Gast)]

Max H. schrieb:
> Das get auch schief: Wenn hilf negativ ist, dann ist BUFFER_SIZE-hilf
> größer als BUFFER_SIZE, z.B. 128 - -6 = 134.

uupps :-), naja, darum bin ich ja noch ein Anfänger und kein 
Fortgeschrittener bzw. Profi, so wie Du. Mir wäre das wahrscheinlich nie 
aufgefallen und ich hätte mich gewundert, warum ich Blödsinn rausbekomme 
:-)

[Anfänger (Gast)]

Guten Morgen!

Aus dem Quellcode würde ich gerne noch die letzte Zeile hier aus dem 
Abschnitt verstehen:

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};

buffer = {{}, 0, 0}

Ich bin mir über die Verwendung der geschweiften Klammern noch im 
Unklaren. Die beiden Nullen dort sind sicherlich als Initialwerte für 
read und write zu verstehen. Mit {} - ist damit gemeint, dass das Array 
data[BUFFER_SIZE] leer sein soll?

Warum kann ich dort überhaupt geschweifte Klammern benutzen? Sorry, wenn 
meine Frage vielleicht trivial ist - aber ich habe in meinem 
C-Anfängerbuch nachgeschaut und noch nicht herausgefunden, warum man 
sagen kann buffer={...}. Ich hab bisher immer gedacht, dass die 
geschweiften Klammern dazu da sind, Funktionsblöcke einzugrenzen.

[Max H. (hartl192)]

Anfänger schrieb:
> Mit {} - ist damit gemeint, dass das Array
> data[BUFFER_SIZE] leer sein soll?
Es wird mit 0 initialisiert.

> warum man sagen kann buffer={...}.
Das ist laut C-Standard einfach so.
> Ich hab bisher immer gedacht, dass die geschweiften Klammern
> dazu da sind, Funktionsblöcke einzugrenzen.
Wie du gesehen hast nicht ausschließlich.

[Peter D. (peda)]

Nicht zu alte Compiler kennen auch eine namentliche Initialisierung:

struct Buffer buffer = { .read = 0, .write = 0 };

[Anfänger (Gast)]

cool, danke für Eure Hilfe.

Ich hab jetzt mal versucht, das C-Programm in eine Klassenstruktur 
umzuwandeln (Headerdatei und cpp-Datei sind jetzt hier in dem 
Codeschnippsel zusammen):

// Headerdatei

class Buffer {
 public:
    uint8_t BufferIn  (uint16_t element);
    uint8_t BufferOut (* element);
    void BufferClear ();
    uint32_t BufferAnzahl ();
 
 private:
    uint16_t data[];
    uint16_t read;
    uint16_t write;
};

// cpp-Datei

uint8_t Buffer::Buffer(uint16_t size) {
    if (size%2 != 0) { 
         return ERROR;
    }
    else {
         read = 0;
         write = 0;
         data = date[size];
         return !ERROR;
    }
}
 
uint8_t Buffer::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;
  int a= ERROR;
}
 
uint8_t Buffer::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;
}

void Buffer::BufferClear()
{
    buffer.read = buffer.write = 0;
}

uint8_t Buffer::BufferAnzahl()
{
    return (buffer.write - buffer.read) & (BUFFER_SIZE - 1);
}

Später würde ich in meinem Programm das so aufrufen:

 if ( (Buffer meinbuffer(1024)) != SUCCESS) 
    { ... Fehler beim Initialisieren des Buffers ...}

Ich bin mir aber nicht sicher, ob im Konstruktor die Zuweisung der 
Arraygröße funktioniert:

 data = date[size];

Könnt ihr mir da vielleicht nochmal ein paar Tipps geben? Kann ich 
überhaupt im Konstruktor eine return-Anweisung machen?

[Anfänger (Gast)]

Könnte ich eigentlich auch mit dem Präprozessor abfangen, dass der 
Initialwert ein Vielfaches von 2 ist?

Das wäre grad meine Idee:

void Buffer::Buffer(uint16_t size) {
#if ((size%2) != 0)
#error BUFFER-SIZE kein Vielfaches von 2
#endif
         read = 0;
         write = 0;
         data = date[size];

}

[Max H. (hartl192)]

Nein, die Präprozessor Anweisungen funktionieren nur mit Konstanten. 
Dann müsstest du 'size' mit einem #define machen.

[Anfänger (Gast)]

Max H. schrieb:
> Nein, die Präprozessor Anweisungen funktionieren nur mit Konstanten.
> Dann müsstest du 'size' mit einem #define machen

ok, danke. Ich brauche in meinem Programm zwei Buffers mit 
unterschiedlichen Größen und wollte gerne die Größe variabel erzeugen 
können - auch für später mal, wenn ich wieder mal nen Buffer brauche.

Aber das hier würde gehen?

uint8_t Buffer::Buffer(uint16_t size) {
    if (size%2 != 0) { 
         return ERROR;
    }
    else {
         read = 0;
         write = 0;
         data = date[size];
         return !ERROR;
    }
}