[C] fifofast - eine schnelle, macro-basierte, generische FIFO (MIT Lizenz)

Dr. Sommer schrieb:
> Eine gute Demonstration, warum C++ templates erfunden wurden...

Da stimm ich dir zu, für C++ Code sind templates die bessere Wahl. Für C 
muss man halt kreativ werden schulterzuck

Hab in den letzten Tagen an fifofast weiter gearbeitet und um folgende 
Features ergänzt:

- Readme komplett überarbeitet (mit vielen Beispielen!)
- automatisiertes Testen des Quellcodes
- inline Funktionen, um auf Fifos per pointer zugreifen zu können
- fifo arrays, falls man mehr als 1 Fifo von der gleichen Art braucht

Wie gehabt ist der Code auf https://github.com/nqtronix/fifofast 
gehostet.

super, Danke !

Ich habe hierbei den seltsamen Fall, dass bei 2 FIFOs gleichen Datentyps und Länge es zu seltsamen Effekten kommt. Der zweite FIFO scheint in einen anderen Rambereich zu schreiben und es kommt zu Problemen woanders im Programm.

So siehts bei mir aus:

_fff_declare(uint16_t, fifo_uint16_1, 128); _fff_declare(uint16_t, fifo_uint16_2, 128);

_fff_init(fifo_uint16_1); _fff_init(fifo_uint16_2);

Im Code nutze ich die Funktion _fff_write zum Schreiben und _fff_read zu Lesen der Daten.

Habe ich hier etwas nicht verstanden?

Viele Grüße

Die declare/init Makros deklarieren und initialisieren die anonyme structs mit den von dir gewählten Namen (fifo_unit16_1/2). Die anderen Makros greifen auf diese structs mit Namen zu. Die structs nutzen natürlich unterschiedliche RAM Adressen, und sollten sich gegenseitig nicht beeinflussen.

Falls du auf eine fifo auf verschiedenen .c Dateien zugreifst: Die "declare" muss in einen .h Header Datei, die von allen relevanten .c Dateien inkludiert wird. Die init nur 1x in einer .c Datei aufrufen. Ansonsten erzeugt du mehrere structs mit gleichem Namen.

Falls du auf eine fifo aus Interrupt UND regulären Funktionen zugreifst: Entweder im Interrupt befüllen und im normalen code auslesen, oder umgekehrt. Niemals von beiden Stellen gleich zugreifen.

Hi,

Danke für deinen Kommentar.

Beide Declare und Init Makros sind in einer .c Datei global angelegt. Das befüllen der FIFOs mit write geschieht nicht im Interruptkontext, werden aber durch das deaktivieren und aktivieren der Interrupts geschützt.

Das Lesen passiert auch in der gleichen Datei, gekapselt durch eine Get-Funktion, sodass ich die Daten von woanders über die Get-Funktion auslesen kann. Zuerst wird aber durch _fff_mem_level überprüft, ob überhaupt Daten vorhanden sind. Danach werden sie durch read ausgelesen.

Ich kann jetzt nicht den echten Code präsentieren, aber das prinzipielle. Das ganze läuft auf einem STM32 ARM M3 Core. [CODE] _fff_declare(uint16_t, fifo_uint16_1, 128); _fff_declare(uint16_t, fifo_uint16_2, 128);

_fff_init(fifo_uint16_1); _fff_init(fifo_uint16_2);

void WriteFifo(uint16_t data_1, uint16_t data_2) { __disable_irq(); //fff_write(fifo_uint16_1, 0); //fff_write(fifo_uint16_2, 0); __enable_irq(); }

uint16_t GetFifoData(uint8_t* pData, uint8_t fifo) { uint16_t tmp = 0; uint16_t i = 0; uint16_t mem_level = 0;

if(fifo == 1) { mem_level = _fff_mem_level(fifo_uint16_1); } else { mem_level = _fff_mem_level(fifo_uint16_2); }

for(i = 0; i < mem_level*2; i+=2) { if(ka == 1) { tmp = _fff_read (fifo_uint16_1); } else { tmp = _fff_read (fifo_uint16_2); } memcpy(&pData[i], &tmp, 2); }

1

return i;

}

[/CODE]

-> Sollte doch alles so in Ordnung sein?

Edit: Ich überlege gerade, ob ich durch memcpy einen Bock verbaue? Hm...

Ansonsten probiere ich mal mit Arrays aus _fff_declare_a

Hi, das Problem liegt auf meiner Seite, nicht an dem fifo. Nur als Info.

Viele Grüße