Division von STD_LOGIC_VECTOR

[hans (Gast)]

Hallo Allerseits,

ich möchte in VHDL eine synthetisierbare Division durchführen. Nun 
möchte ich einen std_logic_vector(35 downto 0) durch einen 
std_logic_vector(23 downto 0) dividieren. Beides sind positive Werte.

Dazu würde ich den Dividenden und den Divisor erst einmal in Typ 
unsigned konvertieren, um mit diesen besser rechnen zu können.

Nun meine Frage: Welcher Algorithmus ist für eine solche Division am 
geeignetsten? Gibt es für solch eine Aufgabe einen fertigen Baustein?

Da mein Dividend und Divisor eine unterschiedliche Länge aufweisen, 
sollte man den kleinen Wert dann mit 0en auffüllen, um auf die gleiche 
Länge zu kommen?

Viele Grüße,

hans

[Dimi S. (Gast)]

Als beispiel kann ich diese Implementierung empfehlen:

http://opencores.org/websvn,filedetails?repname=plasma&path=%2Fplasma%2Ftrunk%2Fvhdl%2Fmult.vhd

Division von 2 32bit vectoren dauert 32 Takte.

Bei Altera' Quartus und Xilinx ISE kann man es mittels
Core-Generator erledigen. Ist aber Hardwarespezifisch.

MfG

[hans (Gast)]

Dimi S., danke für die Info

[hans (Gast)]

Wo finde ich denn das mlite_pack ? Und füge ich das nur in das 
Stammverzeichnis meiner Top Level Entity ein?

Kann das Design ohne weiteres auf 36 Bit modifiziert werden, indem ich 
lediglich die 31 durch die 35, die 32 durch die 36 ersetze und

constant MODE_DIV  : std_logic := '1';

 und

 constant MODE_MULT : std_logic := '0';

 setze?

Jedoch welche Länge muss der Wert muss

signal count_reg   : std_logic_vector(? downto 0);

 besitzen?


Grüße,

hans

[hans (Gast)]

hans schrieb:
> Wo finde ich denn das mlite_pack ? Und füge ich das nur in das
> Stammverzeichnis meiner Top Level Entity ein?

Ist das die vhdl Datei unter plasma\trunk\vhdl\mlite_pack.vhd?

Dann habe ich sie gefunden ;-)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Dimi S. schrieb:
> Als beispiel kann ich diese Implementierung empfehlen:
Ich diese hier  ;-)
http://www.lothar-miller.de/s9y/archives/29-Division-in-VHDL.html

[hans (Gast)]

Vielen Dank Lothar,

was ich jedoch noch nicht so richtig verstanden habe, was die natural 
range 4 to zu bedeuten hat.

Generic ( b  : natural range 4 to 32 := 32 ); -- Breite

Die Breite ist doch dadurch auf 32 vorinitialisiert, oder verstehe ich 
falsch?

Um das Design für zwei 36 Bit Werte zu benutzen, muss doch nur der b 
Generic Parameter auf 36 modifziert werden, oder verstehe ich das 
nochmals falsch? ;)

Vielen Dank,

hans

[Drill Tutor (Gast)]

>was ich jedoch noch nicht so richtig verstanden habe, was die natural
>range 4 to zu bedeuten hat.

>Generic ( b  : natural range 4 to 32 := 32 ); -- Breite


>Die Breite ist doch dadurch auf 32 vorinitialisiert, oder verstehe ich
>falsch?

Nein, da wird nichts "vorinitialisiert", es besagt nur, das wenn bei der 
Instanziierung keine Generic mapping angegeben wird, dann steht b auf 
32.
"natural range" isat hier typdefinition mit bereichseinschränkung. Beim 
generic mapping sollten nur Integer von 4 bis 32 angegeben werden.  Die 
range - Überprüfung muss aber in der simulation meist extra angeschaltet 
werden, ob sich die Synthese drum schert ist auch noch fraglich. Ob das 
Mosul auch mit einer bereichserweiterung auf 36 bit zufriedenstellend 
funktioniert, kannst du nur durch Simu/test überprüfen.
Gruß

[knut (Gast)]

Wenn ich es mit zwei 36 Bit Werten (welche jetzt zwar nicht den vollen 
Bereich ausnutzen)

dividend <= std_logic_vector(to_unsigned(52215,36));
    divisor  <= std_logic_vector(to_unsigned(3534,36));

versuche, kommt zwar der richtige Quotient raus, jedoch ein falscher 
Rest.

Jedoch musste ich dazu ja auch den

Generic ( b  : natural range 4 to 36 := 36 ); -- Breite

setzen, da ansonsten die Fehlermeldung

"tb_division.vhd" Line 46: Expression has 36 elements ; expected 32 " 
kommt, welche bestimmt darauf hinweisen ...

Drill Tutor schrieb:
> Beim
> generic mapping sollten nur Integer von 4 bis 32 angegeben werden

verstehe ich das richtig?

[JBB (Gast)]

Es ist in der Regel möglich, die Eingangsvektoren (Definitionsbereich) 
so zu schieben, dass die Teilung immer mit 32 geschehen kann, was auch 
Sinn macht, weil die Grösse des Ausgangsvektors (Wertebereich) auch 
beschränkt ist.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

hans schrieb:
>> Um das Design für zwei 36 Bit Werte zu benutzen, muss doch nur der b
>> Generic Parameter auf 36 modifziert werden, oder verstehe ich das
>> nochmals falsch? ;)
> Generic ( b  : natural range 4 to 36 := 36 ); -- Breite
Dann solltest du aber vorher schon noch nachsehen, ob du den Algorithmus 
einfach so einfach aufbohren kannst. Aber: ausprobieren kann nicht 
schaden....

[Tom (Gast)]

Ich habe mal eine ganz blöde Frage:

Ich könnte doch einfach die niederwertigsten 4 Bit weg lassen und dann 
den tollen Divisionsalgorithmus von LM nehmen? Da sind doch gerade mal 
16 im Dezimalen bei einer 32 Bit Zahl.

Ich habe nur gerade echt ein Brett vorm Kopf. Kann ich dann einfach 
sagen:

dividend32 <= divident[0:31]

 wenn Dividend vorher ein 36 Bit Signal ist ?

[Tom (Gast)]

nein, so geht es schon mal nicht :(

[Tom (Gast)]

  dividend36 <= std_logic_vector(to_unsigned(15579,36));
  dividend <= dividend36(35 downto 4);

Hmm, so funktioniert es auch nicht.

In der Testbench von LM wird zwar jetzt divisor und dividend36 richtig 
angezeigt, jedoch ist dividend, quotient und remainder 0.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Tom schrieb:
> Hmm, so funktioniert es auch nicht.
Was funktioniert so auch nicht?

> In der Testbench von LM wird zwar jetzt divisor und dividend36 richtig
> angezeigt, jedoch ist dividend, quotient und remainder 0.
?

[Tom (Gast)]

Guten Morgen,

Lothar Miller schrieb:
> Was funktioniert so auch nicht?


ich möchte Deinen Divisionsalgorithmus verwenden. Divisor und Dividend 
haben eine Länge von 32 Bit. Wenn ich nun die niederwertigsten 4 Bit 
Werte eines 36 Bit Signals weg lassen würde und die übrig gebliebenen 32 
Bit Werte deinem Dividenden in der Testbench zuordne, kommt bei 
Dividend, Quotient und Remainder 0 heraus. Dem Dividend wird kein Wert 
zugeorndet.

  dividend36 <= std_logic_vector(to_unsigned(15579,36));       
  dividend <= dividend36(35 downto 4);
        divisor  <= std_logic_vector(to_unsigned(110,32));

    wait for 5 ns;
    start <= '1';
    wait for 25 ns;
    start <= '0';
    wait for 50 ns;

.
.
.

Oder kann ich das so gar nicht umsetzen?