shift right logic

Gast #2917818
Lesenswert?

Hallo zusammen,

ich habe zwei STD_LOGIC_VECTOR(15 downto 0) Signale. line_rate_own und 
line_rate_1. Ich möchte nun dem line_rate_own Signal den halben Wert von 
line_rate_1 zuweisen. Mir ist bewusst, das ich den exakten halben Wert 
nur bei einer zweier Potenz erhalte. Ich möchte also den 16 Bit Vektor 
line_rate_1 um eins nach recht schieben. Dies würde ich mit dem srl 
Operator machen. Ich bekomme jedoch immer folgende Fehlermeldung.

"srl can not have such operands in this context."

Kann mir jemand sagen, welchen Fehler ich mache?

1
line_rate_own <= (std_logic_vector(unsigned(line_rate_1)) srl 1 );
Gast #2917878
Lesenswert?

task schrieb:
> nur aus welchen Grund kann man nicht /2 oder srl einsetzen?

Eine Division ist i.a.R. nicht synthetisierbar (ggf. ist die Synthese 
aber so schlau, zu erkennen, daß es durch einen Shift ersetzt werden 
kann).

Ist "srl" für std_logic_vector überhaupt definiert?
Ich hab da was von "nur für bit_vector" im Hinterkopf...
Moderator (Firma: Titel) Persönliche Seite #2918742
Lesenswert?

Bronco schrieb:
> Ich hab da was von "nur für bit_vector" im Hinterkopf...
Klar: weil du nie einen bit_vector verwendest...   ;-)

task schrieb:
> nur aus welchen Grund kann man nicht /2 oder srl einsetzen?
Weil die Rechnung /2 für std_logic_vector offenbar nicht nicht 
definiert ist. Dafür müsstest du die std_logic_arith verwenden, aber wie 
gesagt: man rechnet nicht mit uneingeschränkten Vektoren!

Aber es ist ein Lichtstreifen am Horizont:
die numeric_std kann wenigstens mal unsigned und signed schieben:
1
--===============================================================
2
-- Shift and Rotate Functions
3
--===============================================================
4
  -- Id: S.1
5
  function SHIFT_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED;
6
  -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0)
7
  -- Result: Performs a shift-left on an UNSIGNED vector COUNT times.
8
  --         The vacated positions are filled with '0'.
9
  --         The COUNT leftmost elements are lost.
10
  -- Id: S.2
11
  function SHIFT_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED;
12
  -- Result subtype: UNSIGNED(ARG'LENGTH-1 downto 0)
13
  -- Result: Performs a shift-right on an UNSIGNED vector COUNT times.
14
  --         The vacated positions are filled with '0'.
15
  --         The COUNT rightmost elements are lost.
Und mit std_logic wäre dann das möglich:
1
   line_rate_own <= std_logic_vector( shift_right(unsigned(line_rate_1),1) );

> Eine Division ist i.a.R. nicht synthetisierbar (ggf. ist die Synthese
> aber so schlau, zu erkennen, daß es durch einen Shift ersetzt werden
> kann).
Das kann die schon lange, denn eine Division eines unsigned durch eine 
Zweierpotenz ist kein Schieben, sondern einfach ein Umverdrahten. Es 
werden einfach die Bits anders weiterverbunden.
Und damit gings natürlich auch so:
1
   line_rate_own <= std_logic_vector( unsigned(line_rate_1)/2 );
Gast #2919010
Lesenswert?

Bronco schrieb:
> Eine Division ist i.a.R. nicht synthetisierbar (ggf. ist die Synthese
> aber so schlau, zu erkennen, daß es durch einen Shift ersetzt werden
> kann).

Schonmal probiert? Ich habe es probiert, und Divisionen sind sehr wohl 
synthetisierbar. Auch bei einem Divisor, der keine Potenz von zwei ist. 
Die Nachkommastellen des Quotienten gehen dabei natürlich verloren und 
der Ressourcenverbrauch ist durch die Kombinatorik nicht ohne, 
Geschwindigkeit ist auch nicht das gelbe vom Ei. Aber generell geht eine 
Division sehr wohl (getestet mit Synplify).
Moderator (Firma: Titel) Persönliche Seite #2919114
Lesenswert?

Bronco schrieb:
> Nee, ich hab's vor gut einem Jahr in einem Lehrgang gelernt, und es
> erschien mir realistisch ;)
Tja, der Lehrer hat das eben auch noch nicht mitbekommen...
Hatten wir aber schon im 
Beitrag "Re: Rechnen mit unsigned vs. signed und einer division"

Es ist also so, dass da bei einer Division durch "keine" Zweierpotenz 
bei der Synthese ein unglaublich großes und langsames Kombinatorikonster 
herauskommt. Dieser einfache Ansatz funktioniert also sinnvoll nur bei 
sehr kurzen Vektoren.

Und da ist noch der Unterschied zwischen "Schieben" und "Teilen" bei 
vorzeichenbehafteten Vektoren aufgeführt:
Beitrag "Re: Integer-Division durch Zweierpotenz - immer synthetisierbar?"

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren