Diskussion:FIFO mit avr-gcc - Versionsgeschichte

Hae am 12. November 2009 um 17:17 Uhr

2009-11-12T17:17:38Z

Hae: Erweiterungsvorschläge

2009-11-12T17:15:51Z

Erweiterungsvorschläge

SprinterSB_alt: /* habe ich hier ein sei(); übersehen ? */

2007-05-12T10:53:14Z

‎habe ich hier ein sei(); übersehen ?

Izaseba: habe ich hier ein sei(); übersehen ?

2007-04-23T19:34:46Z

habe ich hier ein sei(); übersehen ?

PicNick am 6. März 2006 um 06:59 Uhr

2006-03-06T06:59:21Z

SprinterSB_alt am 5. März 2006 um 21:32 Uhr

2006-03-05T21:32:46Z

PicNick am 5. März 2006 um 11:05 Uhr

2006-03-05T11:05:44Z

SprinterSB_alt am 5. März 2006 um 09:02 Uhr

2006-03-05T09:02:51Z

SprinterSB_alt am 5. März 2006 um 09:01 Uhr

2006-03-05T09:01:30Z

SprinterSB_alt am 5. März 2006 um 08:59 Uhr

2006-03-05T08:59:08Z

@@ Zeile 1: / Zeile 1: @@
 Schön wäre es, wenn man auch einen FIFO-Überlauf oder HW-Fehler, wie Framing Error oder Overrun, melden würde.
 Habe das für FIFO-Überlauf mal gemacht.
@@ Zeile 18: / Zeile 21: @@
 	unsigned char *pwrite;              // Schreibzeiger
 	unsigned char read2end, write2end;  // # Zeichen bis zum Überlauf Lese-/Schreibzeiger
-  unsigned char state;
+        unsigned char state;
 } fifo_t;
@@ Zeile 57: / Zeile 60: @@
-Dann noch eine Erweiterung. Ich lese nur ganze Zeilen von der seriellen Schnittstelle. Also fand ich es gut eine Funktion zu haben, die gleich im Fifo nach schaut, ob so eine Funktion vorhanden ist.
+Dann noch eine Erweiterung. Ich lese nur ganze Zeilen von der seriellen Schnittstelle. Also fand ich es gut eine Funktion zu haben, die gleich im Fifo nach schaut, ob eine Zeile vorhanden ist.
 '''fifo.c'''

← Nächstältere Version		Version vom 12. November 2009, 17:15 Uhr
Zeile 1:		Zeile 1:
		+	Schön wäre es, wenn man auch einen FIFO-Überlauf oder HW-Fehler, wie Framing Error oder Overrun, melden würde.
		+	Habe das für FIFO-Überlauf mal gemacht.
		+
		+	Hier meine Erweiterungen zum Code:
		+
		+	'''fifo.h'''
		+
		+	<pre>
		+	enum {
		+	Fifo_Overrun = 1
		+	};
		+
		+	typedef struct
		+	{
		+	unsigned char volatile count; // # Zeichen im Puffer
		+	unsigned char size; // Puffer-Größe
		+	unsigned char *pread; // Lesezeiger
		+	unsigned char *pwrite; // Schreibzeiger
		+	unsigned char read2end, write2end; // # Zeichen bis zum Überlauf Lese-/Schreibzeiger
		+	unsigned char state;
		+	} fifo_t;
		+
		+	static inline uint8_t
		+	_inline_fifo_put (fifo_t *f, const uint8_t data)
		+	{
		+	unsigned char write2end;
		+	unsigned char* pwrite;
		+	unsigned char cRet;
		+
		+	cRet = 0;
		+
		+	if (f->count >= f->size)
		+	{
		+	f->state = Fifo_Overrun;
		+	cRet = 1;
		+	goto end;
		+	}
		+	...
		+
		+	end:
		+	return cRet;
		+	}
		+
		+	static inline uint8_t
		+	_inline_fifo_get (fifo_t *f)
		+	{
		+	unsigned char* pread;
		+	unsigned char data;
		+	unsigned char read2end;
		+
		+	if (f->state) return -2;
		+	if (!f->count) return -1;
		+
		+	...
		+	}
		+	</pre>
		+
		+
		+	Dann noch eine Erweiterung. Ich lese nur ganze Zeilen von der seriellen Schnittstelle. Also fand ich es gut eine Funktion zu haben, die gleich im Fifo nach schaut, ob so eine Funktion vorhanden ist.
		+
		+	'''fifo.c'''
		+	<pre>
		+	int fifo_gets (fifo_t f, char buf, int *len )
		+	{
		+	unsigned char* pread;
		+	unsigned char count;
		+	unsigned char idx;
		+	int result;
		+	unsigned char read2end;
		+
		+	if (f->state) return -2;
		+	if (!f->count) return -1;
		+
		+	pread = f->pread;
		+	count = f->count;
		+	read2end = f->read2end;
		+
		+	result = 1;
		+	idx = 0;
		+	while (count != 0)
		+	{
		+	count--;
		+
		+	if (read2end-- == 0)
		+	{
		+	read2end = f->size-1;
		+	pread -= f->size;
		+	}
		+
		+	buf[idx] = *(pread++);
		+	if (buf[idx] == '\n' \|\| buf[idx] == '\r')
		+	{
		+	result = 0;
		+	break;
		+	}
		+	idx++;
		+	}
		+
		+	/* Wenn ein \r\n gesendet wird ist beim ersten Lesen eine ganze Zeile
		+	* in buf. Beim zweiten Lesen nur 1 Zeichen. In der höherliegenden Logik,
		+	* wird immer eine sinnvolle komplette Zeile erwartet.
		+	* Deshalb wird eine "Zeile" mit nur einem Zeichen ignoriert.
		+	*/
		+	if ((result == 0) && (idx > 1))
		+	{
		+	f->pread = pread;
		+	f->read2end = read2end;
		+
		+	f->count = count;
		+	*len = idx;
		+	buf[idx] = '\0';
		+	}
		+	else
		+	{
		+	buf[0] = '\0';
		+	*len = 0;
		+	}
		+
		+	return result;
		+	}
		+	</pre>
		+
		+	----
	int fifo_get_nowait (fifo_t *b)		int fifo_get_nowait (fifo_t *b)
	Liefert das nächste Byte aus der FIFO als int bzw. -1, falls die FIFO leer ist.		Liefert das nächste Byte aus der FIFO als int bzw. -1, falls die FIFO leer ist.

← Nächstältere Version		Version vom 12. Mai 2007, 10:53 Uhr
Zeile 59:		Zeile 59:
	Gruß Sebastian		Gruß Sebastian
	--[[Benutzer:Izaseba\|izaseba]] 21:34, 23. Apr 2007 (CEST)		--[[Benutzer:Izaseba\|izaseba]] 21:34, 23. Apr 2007 (CEST)
		+
		+	:Hi Sebastian. Durch die letzte Anweisung wird das SREG und insbesondere das darin befindliche I-Flag wieder so hergestellt, wie es ursprünglich war. Wenn der Code immer in einem Kontext ausgeführt wird, in dem Interrupts global aktiviert sind, dann geht es mit einer CLI/SEI-Klammer natürlich etwas simpler. --[[Benutzer:SprinterSB\|SprinterSB]] 12:53, 12. Mai 2007 (CEST)

← Nächstältere Version		Version vom 23. April 2007, 19:34 Uhr
Zeile 40:		Zeile 40:
	g Wenn du Objecte auch als solches reinkriegst, is besser, du legst sie gleich als verkettete Liste an. das ist natürlich mit Heap einiges einfacher. Für Controller wird's da aber eng. geht meist eh' nur ums UART-buffern.		g Wenn du Objecte auch als solches reinkriegst, is besser, du legst sie gleich als verkettete Liste an. das ist natürlich mit Heap einiges einfacher. Für Controller wird's da aber eng. geht meist eh' nur ums UART-buffern.
	--PicNick 07:59, 6. Mär 2006 (CET)		--PicNick 07:59, 6. Mär 2006 (CET)
		+
		+	== habe ich hier ein sei(); übersehen ? ==
		+
		+	Hallo Sprinter :-)
		+
		+	Ich analysiere gerade deine FIFO Puffer, klasse !
		+
		+	Nur eine Frage stellt sich noch, hier
		+	<pre>
		+	uint8_t sreg = SREG;
		+	cli();
		+	f->count--;
		+	SREG = sreg;
		+	</pre>
		+
		+	Muß da nicht noch ein sei(); hin<br/>
		+	Oder hab ich da was übersehen ?<br/>
		+	Gruß Sebastian
		+	--[[Benutzer:Izaseba\|izaseba]] 21:34, 23. Apr 2007 (CEST)

← Nächstältere Version		Version vom 6. März 2006, 06:59 Uhr
Zeile 37:		Zeile 37:

	Noch praktischer wäre natürlich eine FIFO, in der man ganze Objekte speichern kann, und nicht nur einzelne Bytes... --[[Benutzer:SprinterSB\|SprinterSB]] 22:32, 5. Mär 2006 (CET)		Noch praktischer wäre natürlich eine FIFO, in der man ganze Objekte speichern kann, und nicht nur einzelne Bytes... --[[Benutzer:SprinterSB\|SprinterSB]] 22:32, 5. Mär 2006 (CET)
		+	----
		+	g Wenn du Objecte auch als solches reinkriegst, is besser, du legst sie gleich als verkettete Liste an. das ist natürlich mit Heap einiges einfacher. Für Controller wird's da aber eng. geht meist eh' nur ums UART-buffern.
		+	--PicNick 07:59, 6. Mär 2006 (CET)

← Nächstältere Version		Version vom 5. März 2006, 21:32 Uhr
Zeile 32:		Zeile 32:
	Beispiel: Bei IP etc. hab immer 16 Bit als Länge vorn, da lese ich z.B. erst, wenn die auch da sind. Und dann erst weiter, wenn der record komplett ist. Aber für eine Controller-UART etc. ist das vielleicht auch etwas über-drüber.		Beispiel: Bei IP etc. hab immer 16 Bit als Länge vorn, da lese ich z.B. erst, wenn die auch da sind. Und dann erst weiter, wenn der record komplett ist. Aber für eine Controller-UART etc. ist das vielleicht auch etwas über-drüber.
	--PicNick 12:05, 5. Mär 2006 (CET)		--PicNick 12:05, 5. Mär 2006 (CET)
		+
		+	Jo, das geht auch. Auf <tt>fifo.count</tt> kann man ja frei zugreifen. Beim nachfolgenden Lesen sind aber evtl. mehr Zeichen im Puffer, was bei den meisten Anwendungen nicht stört. Es sollte nur ein einfaches Grundgerüst sein, das man nach eigenem Gusto erweitern kann, etwa
		+	static inline int fifo_contains_at_least_n_bytes_p (const fifo_t * f, const unsigned char num) { f->count >= num; }
		+
		+	Noch praktischer wäre natürlich eine FIFO, in der man ganze Objekte speichern kann, und nicht nur einzelne Bytes... --[[Benutzer:SprinterSB\|SprinterSB]] 22:32, 5. Mär 2006 (CET)

← Nächstältere Version		Version vom 5. März 2006, 11:05 Uhr
Zeile 21:		Zeile 21:
	----		----
	In der FIFO stehen ja nur Werte >= 0. Und der Rückgabewert ist auch immer >= 0, wenn was drinne ist, ansonsten eben <0. Ich erweitere also den Wertebereich. Ausserdem kann auf <0 sehr effizient getestet werden. Wie würdest du es machen? --[[Benutzer:SprinterSB\|SprinterSB]] 09:59, 5. Mär 2006 (CET)		In der FIFO stehen ja nur Werte >= 0. Und der Rückgabewert ist auch immer >= 0, wenn was drinne ist, ansonsten eben <0. Ich erweitere also den Wertebereich. Ausserdem kann auf <0 sehr effizient getestet werden. Wie würdest du es machen? --[[Benutzer:SprinterSB\|SprinterSB]] 09:59, 5. Mär 2006 (CET)
		+
		+	----
		+	Mach nur, die Geschmäcker sind halt verschieden, absolute Wahrheiten gibt's nicht. Ich trenne immer Frage und Abholen, wobei die Frage immer non-destruktiv nach der verfügbaren Länge ist.
		+	<pre>
		+	while (fifo_data() >= required_length ) // anzahl im Buffer
		+	{
		+	Uns_16 = fifo_read_short() // oder ähnlich
		+	}
		+	</pre>
		+	Beispiel: Bei IP etc. hab immer 16 Bit als Länge vorn, da lese ich z.B. erst, wenn die auch da sind. Und dann erst weiter, wenn der record komplett ist. Aber für eine Controller-UART etc. ist das vielleicht auch etwas über-drüber.
		+	--PicNick 12:05, 5. Mär 2006 (CET)

@@ Zeile 20: / Zeile 20: @@
 --PicNick 08:59, 5. Mär 2006 (CET)
 ----
-In der FIFO stehen ja nur Werte >= 0, und der Rückgabewert ist auch immer >= 0, wenn was drinne ist, <0 sonst. Ich erweitere also den Wertebereich. AUsserdem kann auf <0 sehr effizient gesestet werden. Wie würdest du es machen? --[[Benutzer:SprinterSB|SprinterSB]] 09:59, 5. Mär 2006 (CET)
+In der FIFO stehen ja nur Werte >= 0. Und der Rückgabewert ist auch immer >= 0, wenn was drinne ist, ansonsten eben <0. Ich erweitere also den Wertebereich. Ausserdem kann auf <0 sehr effizient getestet werden. Wie würdest du es machen? --[[Benutzer:SprinterSB|SprinterSB]] 09:59, 5. Mär 2006 (CET)

← Nächstältere Version		Version vom 5. März 2006, 08:59 Uhr
Zeile 19:		Zeile 19:
	d.h. du verwendest die Bits >8 implizit als Schalter ? naja.		d.h. du verwendest die Bits >8 implizit als Schalter ? naja.
	--PicNick 08:59, 5. Mär 2006 (CET)		--PicNick 08:59, 5. Mär 2006 (CET)
		+	----
		+	In der FIFO stehen ja nur Werte >= 0, und der Rückgabewert ist auch immer >= 0, wenn was drinne ist, <0 sonst. Wie würdest du es machen? --[[Benutzer:SprinterSB\|SprinterSB]] 09:59, 5. Mär 2006 (CET)