Fifo mit Zeigern?

Hi,

welchen Sinn würde es machen, diesen funktionierenden Fifo-Sketch so umzubauen, dass Zeiger anstatt Variablen auf die Lese- Schreibpositionen zeigen würden?

Es ist schon eine ganze Weile her, dass ich mich mit dem Thema Ringpuffer beschäftigte, aber in Erinnerung blieb mir, dass ich das mal auf eine "Zeigervariante" umbauen wollte. Warum weiss ich jedoch nicht mehr. Was ich jedoch noch weiss ist die Tatsache, dass mir der Umbau nicht glückte. :P

Gruß Chris

#define FIFOSIZE 32                                                                 // Einmalig festgelegte Puffergröße
char fifo[FIFOSIZE];                                                                // Der Puffer an sich (in diesem Fall ein char-Array)
byte fifoWriteIndex = 0;                                                            // Schreibindex
byte fifoReadIndex = 0;                                                             // Leseindex

void setup()
{
  Serial.begin(9600);
  delay(2000);
  Serial.println("Start");
  fifoWrite('a');
  fifoWrite('b');
  fifoWrite('c');
  fifoWrite('d');
  fifoWrite('e');
  fifoWrite('f');
  fifoWrite('g');
  fifoWrite('h');
  fifoWrite('i');
}

void loop()
{
  if (fifoAvailable()) Serial.println(fifoRead());  // Sobald sich mind. ein Zeichen im Puffer befindet, diesen auslesen
  delay(100);
  einmaligeFuetterung();
  spaetereFuetterung();
}

void fifoWrite(char c)                                                              // Schreibfunktion
{
  fifo[fifoWriteIndex] = c;                                                         // Schreiben des eingehenden Zeichens an die aktuelle Indexposition
  c = fifoWriteIndex;                                                               // Aktuelle Indexposition zwischenspeichern (in diesem Fall im c char um Speicherplatz zu sparen)
  fifoWriteIndex++;                                                                 // Indexposition inkrementieren
  if (fifoWriteIndex >= FIFOSIZE) fifoWriteIndex = 0;                               // Wenn das Ende des Puffers erreicht wird, die Schreibposition auf den ersten Index setzen
  if (fifoReadIndex == fifoWriteIndex) fifoWriteIndex = c;                          // Schutzfunktion, wenn mehr Zeichen in den Puffer geschrieben werden sollen, als dieser fassen kann
}

void einmaligeFuetterung()
{
  static boolean s = 0;
  if (s == 0)
  {
    fifoWrite('1');
    fifoWrite('2');
    fifoWrite('3');
    fifoWrite('4');
    fifoWrite('5');
    fifoWrite('6');
    fifoWrite('7');
    fifoWrite('8');
    fifoWrite('9');
    fifoWrite('0');
    fifoWrite('j');
    fifoWrite('k');
    fifoWrite('l');
    fifoWrite('m');
    fifoWrite('n');
    fifoWrite('o');
    fifoWrite('p');
    fifoWrite('q');
    fifoWrite('r');
    fifoWrite('s');
    fifoWrite('t');
    fifoWrite('u');
    fifoWrite('v');
    fifoWrite('w');
    fifoWrite('x');
    fifoWrite('y');
    fifoWrite('z');
    s = 1;
  }
}

void spaetereFuetterung()
{
  static boolean z = 0;
  if (millis() >= 10000 && z == 0)
  {
    fifoWrite('1');
    fifoWrite('2');
    fifoWrite('3');
    fifoWrite('4');
    fifoWrite('5');
    fifoWrite('6');
    fifoWrite('7');
    fifoWrite('8');
    fifoWrite('9');
    fifoWrite('0');
    fifoWrite('j');
    fifoWrite('k');
    fifoWrite('l');
    fifoWrite('m');
    fifoWrite('n');
    fifoWrite('o');
    fifoWrite('p');
    fifoWrite('q');
    fifoWrite('r');
    fifoWrite('s');
    fifoWrite('t');
    fifoWrite('u');
    fifoWrite('v');
    fifoWrite('w');
    fifoWrite('x');
    fifoWrite('y');
    fifoWrite('z');
    z = 1;
  }
}

// Vor dem Aufruf von "fifoRead()" muss immer zuerst mit "fifoAvailable()" geprüft werden, ob sich ein neues Zeichen im Ringbuffer befindet.

boolean fifoAvailable()  // Diese Funktion prüft, ob sich ein neues Zeichen im Ringbuffer befindet
{
  return (fifoReadIndex != fifoWriteIndex); // Ein neues Zeichen befindet sich im Ringbuffer wenn (fifoReadIndex != fifoWriteIndex)
}

char fifoRead()                                                                     // Lesefunktion
{
  char c;                                                                           // Zeichen initialisieren
  c = fifo[fifoReadIndex];                                                       // Zeichen aus Ringbuffer lesen
  fifoReadIndex++;                                                                  // Leseindex um eine Stelle erhöhen
  if (fifoReadIndex >= FIFOSIZE) fifoReadIndex = 0;                                 // Beim erreichen des Arrayendes den Leseindex auf null zurücksetzen
  return c;                                                                         // Zeichen zum Abschluss aus der Funktion übergeben
}

Chris72622: welchen Sinn würde es machen, diesen funktionierenden Fifo-Sketch so umzubauen, dass Zeiger anstatt Variablen auf die Lese- Schreibpositionen zeigen würden?

Worauf willst Du mit Deiner Frage hinaus? Wenn es beim Umbau etwas zu lernen gibt, wäre das für mich ein guter Grund. Noch mehr wäre ich motiviert, wenn es mich bei einem aktuellen Problem weiter brächte.

Gruß

Gregor

Ob sich ein Umbau auf Geschwindigkeit und Größe des Sketches positiv auswirken würde.

Gruß Chris

Zeiger oder Indices sollte nicht viel Unterschied machen

  • bei Manipulationen/Tests liegen die Indices vorne
  • bei den Zugriffen die Zeiger
  • Zeiger nehmen doppelt soviel Platz ein (RAM)Wenn du den Sketch kleiner machen willst, schreib eine fifoWrite(const char* text) Funktion.

Arrays kann man nur mit Zeigern beackern. Und wenn man das nicht explizit tut, spätestens der Compiler macht es sich dann implizit.

dass Zeiger anstatt Variablen auf die Lese- Schreibpositionen zeigen würden?

Aha! Zeiger müssen also nicht in Variablen gehalten werden? Das wusste ich auch noch nicht.

Dein "Index", darf 8 Bit breit sein. Ein "Zeiger" ist immer 16 Bit breit

Irgendeinen Gewinn würde ich mir davon nicht erwarten! Ich halte das für eine Mikrooptimierung.

von wahsaga: Forenposting mit Performancefrage Bewertungsfaustregel: Wer Fragen nach der Performance solcher Kinkerlitzchen stellt, der programmiert vermutlich noch nicht mal ansatzweise performant. Andernfalls, wenn er wirklich und zu Recht an einer Applikation arbeiten würde, bei der dieses Quentchen entscheidend ist, sollte er diese Frage gar nicht mehr stellen müssen.

combie:
beackern

Was ist das? Danke.

Gruß Chris

Was ist das?

Beackern?

Ein Acker ist die Anbaufläche eines Landwirtes. Er beackert, den Acker. Zeitgemäßer wäre wohl "bewirtschaften".

Und hier ist deine FiFo, dein Acker.

hmmm, beackern…wie erklär’ ich das am besten?

ha, weiß schon, mittels beispiel:

wenn Deine frau schwanger ist, wurde sie wahrscheinlich vom postboten beackert.

gruß stefan

Ah jetzt. Dachte zuerst an sowas, aber das schreibt man ja anders. :D

Gruß Chris