* can not have such operands in this context

[Dori (Gast)]

Hallo,

bitte entschuldigt aber ich sitze jetzt seit zwei Tagen über einer Zeile 
und sehe einfach das Problem nicht. Im Netz findet man zu der 
Fehlermeldung zwar viel aber konkret zu meinem Problem passte kein hit.

Ich habe folgende Zeile in meiner architecture:

use work.blubb.all;

entity blubb is
 Port();
end blubb;

architecture behave of blubb is

signal shiftreg : STD_LOGIC_VECTOR((unsigned((piclength*2 + 3) * 
buswidth)'length-1) Downto 0)

begin

end architecture;

piclength und buswidth sind im package als constant integer eingetragen. 
Ich war zugegebenermassen einfach davon ausgegangen sowas tun zu dürfen.

Die Fehlermeldung kommt seitdem ich die Zeile auf die constants 
umgeschrieben habe. Vorher lief die Synthese durch:
Line 26. * can not have such operands in this context.

Kann mir jemand sagen woran es liegt bzw ob so eine Berechnung an der 
Stelle zulaessig ist? Grundsätzlich sehe ich dort auch keine 
Typunklarheiten.

LG & danke schonmal
Dori

[dito (Gast)]

Sorry, aber das was du geschrieben hast ist kompletter Unsinn. Ich kann 
weder deiner Beschreibung noch deinem Qualltext entnehmen, was du 
überhaupt machen möchtest. Sag uns das erstmal, dann kann dir auch 
geholfen werden.

[Dori (Gast)]

Hm ganz einfach, ich moechte ein Signal, besser einen STD_LOGIC_VECTOR, 
deklarieren und zwar in Abhängigkeit von bestimmten constants. Die 
beiden multipliziert miteinander plus einen offset ergeben eine Integer 
Zahl (so die Hoffnung), wird diese nach unsigned konvertiert sollte die 
bitlänge des entstandenen vektors (-1 natürlich), die obere Grenze 
meines Signals ergeben.

Mehr will ich gar nicht, das restliche Design läuft ohne Probleme, das 
Signal mit einem passenden Absolutwert auch. Es geht hier nur darum den 
Code so umzubauen, dass das package für beliebige busbreiten 
funktioniert und dafuer ist es aufgrund der Struktur notwendig diese 
bitlänge dynamisch bzw in Abhängigkeit von den erwähnten constants zu 
halten.

Den restlichen Code hatte ich nur abrisshaft dazugetan damit man sieht 
an welcher Stelle das Signal deklariert wird.

Gruß & Dank
Dori

[Marius W. (mw1987)]

Ich wünsche dir viel Spaß beim Problemfinden. Denn mit dem was du 
gepostet hast, kann niemand etwas anfangen. Poste den KOMPLETTEN Code 
mit allem was dazu gehört. Sonst wird dir hier niemand helfen 
können/wollen.

Gruß
Marius

[Da D. (dieter)]

Marius Wensing schrieb:
> Ich wünsche dir viel Spaß beim Problemfinden. Denn mit dem was du
> gepostet hast, kann niemand etwas anfangen. Poste den KOMPLETTEN Code
> mit allem was dazu gehört. Sonst wird dir hier niemand helfen
> können/wollen.

Quatsch. Für diese Fragestellung braucht niemand den kompletten Code.

@Dori:
Das Problem lautet kurzgesagt: du willst den 2er Logarithmus einer Zahl 
berechnen. Denn der Logarithmus sagt dir, wieviel Bits du für eine 
bestimmte Integerzahl brauchst.  Versuchs mal damit:

constant width : integer := integer(ceil(log2( (piclength*2 + 3) * buswidth)));
signal shiftreg : STD_LOGIC_VECTOR(width-1 Downto 0);

Dazu brauchst du das package IEEE.math_real

[Dori (Gast)]

Vielen Dank für die Hilfe. Eine kleinere Frage hätte ich noch. Ich habe 
nun versucht herauszubekommen inwieweit mein synthesetool (xst/ise 
webpack 14.1) das math_real package unterstützt. Dazu findet sich im 
Guide folgende Aussage:
"Functions and procedures in the math_real packages, as well as the real 
type, are for
calculations only. They are not supported for synthesis in XST."

Ich vermute das ist der Hinweis, dass diese Funktionen nur für 
Simulationen zu gebrauchen sind?

Ich hatte außerdem nach genaueren Quellen zum Syntheseprozess gesucht, 
um herauszufinden ob es eine Art preprocessing gibt. Mein Beispiel wäre 
im Grunde eine Berechnung, die im Vorlauf einer eigentlichen Synthese 
passieren könnte.

Falls jemand eine schnelle Antwort hat wäre ich dafür sehr dankbar, 
falls nicht ist mir auch mit dieters' sehr geholfen.

Nochmals Grüße,
Dori

[Da D. (dieter)]

Dass du dir Gedanken um die synthetisierbarkeit von den Funktionen 
machst ist sehr löblich :-)

In diesem Fall gehts aber trotzdem: Da die Funktionen konstante Inputs 
haben, werden die bereits bei der Synthese berechnet und nur noch das 
Ergebnis daraus verwendet. Die eigentlichen Funktionen müssen also nicht 
in Hardware synthetisiert werden.