Ringpuffer mit Offset im read und write pointer

Thomas schrieb:
> read Adressen :   1 3 5     2 4 6     1 3 5      2 4 6      1 3 5 usw.
Wann findet denn da die Umschaltung von gerade nach ungerade statt? 
Immer am "Ende" des "Rings"? Ist dir klar, das ein Ring per Definition 
eigentlich kein Ende hat?

> Kann mir jeamnd ein kurzes Code Beispiel schreiben?
Ist das jetzt dein Ernst?
Wofür brauchst du das?
Was ist dein Speicher?

So wie ich das sehe, sind das doch einfach zwei Ringpuffer,
die abwechselnd verwendet werden ? ?

Du könntest immer das Ende eines Durchlaufs erkennen, also wann die 
höchste Addresse erreicht wurde und dann das um 1 verschieben.

Also du nutzt ja jede 2. Addresse, also 1. Durchlauf:
1 3 5 7 9 ... 1023, Ende erkennen, also ein einziges Mal eine Addresse 
um 1 oder 3 erhöhen, dann zweiter Durchlauf
2 4 6 8 ... 1024, wieder Ende erkennen.

Tja und das musst du halt für Lese- und Schreiboperation so bauen, dass 
die jeweils das gewünschte bekommen.

Ich sehe darin nur keinen Sinn?!

Willst du den Speicher für zwei Operationen aufteilen? Vielleicht kannst 
du dann der einen generell alle geraden und der anderen alle ungeraden 
Addressen geben, einfacher wäre es aber jeder seinen Addressbereich zu 
geben.

Also erkläre mal wozu du das brauchst, man kann es vermutlich anders 
lösen.

Wenn du (2^n)-1 nimmst, kannst du doch immer +2 machen, oder?

lg

Gute Idee! Hatte ich gar nicht dran gedacht ...

Christopher B. schrieb:
> Wenn du (2^n)-1 nimmst, kannst du doch immer +2 machen, oder?
Und wer macht dann den Überlauf?

Ach so, ja, man würde dann lesen und schreiben bei entweder geraden oder 
ungeraden Addressen machen und eben nicht versetzt. Also muss man doch 
verschieben wie ich oben schrieb.
Und damit lesen und schreiben jeweils die anderen Adressen nutzen müsste 
man die Zahl der Durchläufe zählen oder irgendwie etwas bauen das sagt 
was gerade die garaden und was die ungeraden Addressen nutzen soll.

Das Problem weshalb das aber nicht Sinnvoll ist:
Wenn der Puffer eben eben nicht voll ist, also nur langsam geschrieben 
wird, dann müsste man mit dem Lesen immer warten. Also man schreibt 
zuerst alle ungeraden Addressen und erst danach beginnt man diese zu 
lesen und schreibt die geraden Addressen. Also eher sehr komisch.

Mir ist aber immer noch nicht klar wozu das nützlich sein soll.

Hallo,

Thomas schrieb:
> 1.Umlauf     2.Umlauf  3.Umlauf  4. Umlauf  5. Umlauf
>
> write Adressen: 1 2 3 4 5 6   1 3 5     2 4 6      1 3 5      2 4 6 usw.
>
> read Adressen :   1   3   5   2 4 6     1 3 5      2 4 6      1 3 5 usw.


bekommt man nicht die gleiche Funktionalität, wenn man die 
Speicheradressen einfach umbenennt? Zum Beispiel so

                1.Umlauf     2.Umlauf  3.Umlauf  4. Umlauf  5. Umlauf

write Adressen:   4   5   6   1 2 3     4 5 6      1 2 3      4 5 6 usw.

read Adressen :   1   2   3   4 5 6     1 2 3      4 5 6      1 2 3 usw.

dann müsste man lediglich beim Initialisieren 1-3 einmal beschreiben.

Gruß Kai

Lothar Miller schrieb:
> Und wer macht dann den Überlauf?

Ich hab leider keine Ahnung von VHDL, ich hab nur etwas nachgedacht und 
bin darauf gekommen. Vielleicht hat es ihm ja etwas genutzt.

lg

Christopher B. schrieb:
> Ich hab leider keine Ahnung von VHDL, ich hab nur etwas nachgedacht und
> bin darauf gekommen.
Mit VHDL wird Hardware beschrieben. Und aus VHDL wird dann letztliche 
Hardware gemacht. Nur gibt es in richtiger Hardware eben keinen Zähler, 
der so einfach und von sich aus an einer 2^n-1 Grenze überlaufen würde.

Thomas schrieb:
>                   1.Umlauf    2.        3.         4.        5. Umlauf
> write Adressen: 1 2 3 4 5 6   1 3 5     2 4 6      1 3 5      2 4 6 usw.
> read Adressen :   1   3   5   2 4 6     1 3 5      2 4 6      1 3 5 usw.
Wenn man den ersten Durchlauf/Initialisierung weglassen könnte, dann 
wäre das unglaublich einfach: ein stinknormaler Ringpuffer ohne Offest 
und sonstwas. Denn dann ist die Schreibreihenfolge gleich der 
Lesereihenfolge:
> write Adressen:               1 3 5     2 4 6      1 3 5      2 4 6 usw.
> read Adressen :   1   3   5   2 4 6     1 3 5      2 4 6      1 3 5 usw.
Schreibreihenfolge: 135246135246
Lesereihenfolge:    135246135246

Ich würde da einfach mal behaupten, dass dieser "Ringpuffer in 
Wirklichkeit ein Fifo ist. Und bei einem Fifo sollten aber m.E. die 
Schreib und Leseadressen unabhängig sein. Deshalb sollte es da 2 
Adresszähler geben...

Oder ist da tatsächlich eine starre Kopplung benötigt?

Es stellt sich also die Frage:
Thomas schrieb:
> ich würde in VHDL gerne eine Art Ringpuffer realisieren
WOFÜR?