mit sll shiften

[abumarcel (Gast)]

Hallo,

ich versuche einen vektor der größe 166 zu füllen, und zwar durch die 
sll funktion. ich will in 5 takte 5 mal 32 bit rein schreiben. wobei ich 
erstmal die Inhalt verschiebe und dann die neuen bits anhänge.

if (r.i /= 5) then

  v.Mem_in := r.Mem_in sll 32;
  v.Mem_in(31 downto 0) := config_data;  
  v.i := r.i + 1 ;        
  else if (r.ready(1) = '0') then
  v.Mem_in := r.Mem_in sll 2;
  v.Mem_in(1 downto 0) := config_data(1 downto 0);
  v.ready(1) := '1';

aber ich bekomme immer einen Fehler: "sll can not have such operands in 
this context."

ich freue mich sehr auf eure Vorschläge.
Danke

[Duke Scarring (Gast)]

Die Definition von SLL sieht so aus:

...
package NUMERIC_STD is
...

function "sll" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED is
...

function "sll" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is
...

Deine 32 sieht sehr nach integer aus. Aber wie ist v.Mem_in und r.Mem_in 
definiert? SLL nimmt nur unsigned und signed ...

Duke

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

Duke Scarring schrieb:
> Die Definition von SLL sieht so aus:
D.h. auch wenn Mem_in ein unsigned oder signed wäre, wäre trotzdem 
der Syntax des Funktionsaufrufs falsch. Besser wäre dann das:

v.Mem_in := sll(r.Mem_in,32);

Aber diese unglaubliche Anhäufung von Variablen verleitet mich sehr zur 
Annahme, dass hier ein Softwerker mal Hardware beschreiben will. Dazu 
sollte aber erst mal die Denkweise umgestellt werden...

abumarcel schrieb:
> ich versuche einen vektor der größe 166 zu füllen, und zwar durch die
> sll funktion.
Das ist evtl. die falsche Vorgehensweise. Ich würde hier einen Mux 
nehmen und den Index für den Vektorzugriff entsprechend berechnen. Denn 
nur so wird das dann in der Hardware umgesetzt werden können...

[Duke Scarring (Gast)]

Lothar Miller schrieb:
> Aber diese unglaubliche Anhäufung von Variablen verleitet mich sehr zur
> Annahme, dass hier ein Softwerker mal Hardware beschreiben will.

Nunja, für mich sieht es nach der 2-Prozess-Methode aus [1].
Für Fortgeschrittene eine sehr feinde Sache m.E., aber nicht für 
Anfänger geeignet, die noch kein Gefühl dafür haben, was aus einer 
Beschreibung synthetisiert wird.

Duke

[1] http://www.gaisler.com/doc/vhdl2proc.pdf

[abumarcel (Gast)]

Hallo leute,

erstmal danke für den Antworten.

Duke Scarring schrieb:
> Die Definition von SLL sieht so aus:

ja aber wie kann man dann so was schreiben : x <= x sll 1;

und

Lothar Miller schrieb:
> Das ist evtl. die falsche Vorgehensweise. Ich würde hier einen Mux
>
> nehmen und den Index für den Vektorzugriff entsprechend berechnen. Denn
>
> nur so wird das dann in der Hardware umgesetzt werden können...

ja aber das ist eine schlichte verfahren was du meinst, weil so werden 
viele leitungen gesetzt um diesen Mux. zu realisieren und das verbraucht 
viele resourcen. und ich habs am anfang so gemacht wie du gesagt hast, 
aber dann hat mich mein Betreuer darauf hingewiesen und mit sll zu 
arbeiten.

Duke Scarring schrieb:
> Nunja, für mich sieht es nach der 2-Prozess-Methode aus [1].
>
> Für Fortgeschrittene eine sehr feinde Sache m.E., aber nicht für

genau, die ganze projekt soll in der 2 prozess-methode implementiert 
werden, und Mem_in ist von type std_logic_vector(161 downto 0).

Gruß, Hani

[D. I. (Gast)]

Und was glaubst du kommt bei diesem Shifter raus?

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

abumarcel schrieb:
> ja aber das ist eine schlichte verfahren was du meinst, weil so werden
> viele leitungen gesetzt um diesen Mux. zu realisieren und das verbraucht
> viele resourcen.
Wie, meinst du denn, sollte das ohne Mux gehen?
Ein Barrelshifter braucht garantiert mindestens genausoviel Platz.
Denn auch ein Barrelshifter ist ein Multiplexer... :-o

> ja aber wie kann man dann so was schreiben : x <= x sll 1;
Welche Libs verwendest du? Als Tipp:

use ieee.numeric_std.all;

und daraus den Datentyp

signal x : unsigned(160 downto 0);

Dann geht das.

abumarcel schrieb:
> und Mem_in ist von type std_logic_vector(161 downto 0).
Also, du wolltest es so:

use ieee.numeric_std.all;
:
:
  v.Mem_in := std_logic_vector(unsigned(r.Mem_in) sll 32);