Hallöchen, ich habe folgendes Problem:

port_map mit sieben STD_LOGIC ausgängen die ich intern in der
architecture "auf einen schlag" setzten will.

Als nebenläufige Anweisung habe ich gedacht, dass:
vari := A & B & C & D & E & F & G;
funzt, wenn vari als:
signal   vari : STD_LOGIC_VECTOR (6 downto 0);
in der architecture definiert wird.

Xilinx spuckt mir aber folgendes aus:
parse error, unexpected AFFECT, expecting OPENPAR or TICK or LSQBRACK

Was übersehe ich ?

Du wirfst Variablen und Signale durcheinander, mit & hat das nix zu tun.

Konkret: Du definierst "vari" als Signal, benutzt dann aber := also den
Zuweisungsoperator für Variablen.

Hey, erstmal danke für die schnelle Antwort :-)

Das hatte ich mir auch schon überlegt, ABER:
Nehme ich statt den Zuweisungsoperator schlichtweg die Signalzuweisung,
so quittiert mir Xilinx das mit:
Object A of mode OUT can not be read
   "   B  "   "   "   "   "   "   "   usw.


Mit meinem Latein bin ich da leider schon am Ende, Google hilft mir
nicht weiter, und das (hochgelobte) Buch von J.Reichardt & B.Schwarz
gibt mir auch keine konkreten Anhaltspunkte.

Wenn du mehrere Signale "auf einen schlag" setzen willst solltest du
einen Vektor daraus machen und nicht einzelne Signale nutzen. So wie du
das machen wolltest geht es nicht, du kannst auf diese Weise keine
Signale zusammenfassen, sondern nur die Werte zuweisen.

Alles klar :-)

Ich brauche die Signale an der Entity aber einzeln, weil real ein Pin
dran hängt.
Ich habe es vorläufig mal so gelöst:
A <= vari(0); usw. was allerdings meiner Meinung doch nicht das Optimum
sein kann...

gutes Nächtle

..."weil real ein Pin"... -=> PRO std_logic! [also insgesamt sieben
PINs]!
nicht das es hier noch zu krassen Missfairständnissen kommt.

Zuweisung: von Signal u. Variable
library ieee;
use ieee.std_logic_1164.all;

entity sig_var is
port(  d1, d2, d3:  in std_logic;
  res1, res2:  out std_logic);
end sig_var;

architecture behv of sig_var is

  signal sig_s1: std_logic;

begin

  proc1: process(d1,d2,d3)

    variable var_s1: std_logic;

  begin
  var_s1 := d1 and d2;
  res1 <= var_s1 xor d3;
  end process;


  proc2: process(d1,d2,d3)
  begin
  sig_s1 <= d1 and d2;
  res2 <= sig_s1 xor d3;
  end process;

end behv;

Du kannst auch einen std_logic_vector nutzen wenn du reale Pins
verbinden willst. Du kannst in der ucf Datei einzelne Bits deines
Vektors mit Pins verbinden.

"Object A of mode OUT can not be read"

Objekt A ist im Entity Block als OUT-Port definiert,
kann also nicht gelesen werden.

Anscheinend hat Jörg als einziger mal die Problemstellung gelesen :)

Die Signale sind als OUT definiert, und VHDL schreibt dann vor, dass
diese Signale nicht als Eingang für irgendwas verwendet werden (frag
mich nicht warum). Du musst stattdessen Zwischensignale lokal
definieren, die du dann schreiben und lesen kannst, und diese 1:1 den
Ausgangsports zuweisen.

Man kann alternativ Object A auch als INOUT-PORT definieren, was ein
zusätzliches Signal einspart. Allerdings ist das (folgt man div.
Code-Design-Styles) max auf Top-Level-Ebene(n) empfehlenswert. Mögliche
Gründe für diese Einschränkung sind z.B. Tri-State-Bubbles etc.
Sogesehen ist allgemein in solchen Fällen der Vorschlag von Morin noch
der beste (falls man sich nicht doch noch das Auslesen von A einsparen
kann).

P.S. Xilinx ISE spuckt sehr häufig Fehlermeldungen wie z.B.
"parse error, unexpected AFFECT, expecting OPENPAR or TICK or LSQBRACK"
aus. Es braucht schon ein wenig Übung/Erfahrung, bis man mit solchen
Meldungen umgehen kann (jedenfalls für mich als Sonntagsprogrammierer).

Vielen, vielen Dank für die replays!

So wie ich das Interpretiere hat Morin das bestätigt was ich vermutet
habe:
Vektor intern anlegen, damit man damit gut arbeiten kann, allerdings
folgt die Zuweisung dann einzeln zu den Ausgangspins, was für 7Bits ja
überhaupt noch keine Schreibarbeit ist.
A <= vari(0);
B <= vari(1);
"  "      "   etc...
Wenn man allerdings Vektoren von z.B. 128Bit haben sollte, könnte das
ganz schön nervig sein.
Und genau deshalb frage ich mich, warum der Verkettungsoperator nicht
'vise versa' genutzt werden kann, z.B.:
A & B & C & ... nX <= vari;  -- wenn vari als STD_LOGIC_VECTOR
                             -- genauso breit ist wie die Anzahl an
                             -- Ausgängen die man so Verknüpfen "könnte"

Chears

Normalerweise benutzt man, wenn man einen Vektor ausgeben möchte, auch
einen Vektor und keine einzelnen Bits. Macht man es doch, muss man mit
der Schreibarbeit leben.

Ich möchte mich der Frage anschliesen:

Wenn ich z.B. drei Vektoren A,B und C habe, wie kann ich dann in
einer Anweisung (um Code zu sparen) eine Zuweisung der Form

   A & B <= C;

machen? Ich kann ja auch über ALIAS-Funktionalität Teile von A bzw. B
bequem (d.h. lesefreundlich) verwenden. Aber ich kann über ALIAS A und B
nicht gleichzeitig referenzieren.

Gruss

Hier wird an einem PCI-BUS Decoder mit XOR Verkettet.
Um das Parity bit zu generieren.
Hilft das weiter ???
------------------------------------------------------------------
     -- This procedure calculate parity of signals address_data(31..0)
     -- and c_be(3..0) and return par_bit
     ------------------------------------------------------------------
     procedure PARITY(
        address_data : in    STD_LOGIC_VECTOR(31 downto 0);
        c_be         : in    STD_LOGIC_VECTOR(3 downto 0);
        par_bit      : inout STD_LOGIC)   is
     begin
        par_bit := '0';
        for I in 0 to 31 loop
            par_bit := par_bit xor address_data(I);
        end loop;

        for I in 0 to 3 loop
            par_bit := par_bit xor c_be(I);
        end loop;

        if (par_bit = 'X' or par_bit = 'U') then
          par_bit := 'Z';
        end if;
     end PARITY;

Gruss Holger.

Jörg wrote:
> Ich möchte mich der Frage anschliesen:
>
> Wenn ich z.B. drei Vektoren A,B und C habe, wie kann ich dann in
> einer Anweisung (um Code zu sparen) eine Zuweisung der Form
>
>    A & B <= C;

Geht nicht, du musst A und B getrennt zuweisen. Der Operator
funktioniert nur auf der rechten Seite.

Dann hat sich das ganze also erledigt.

Zusammengefasst:

Hat man in der Entity viele STD_LOGIC Pins, und keinen STD_LOGIC_VECTOR,
so muss man auch in der Architecture jeden Pin einzeln zuweisen wenn
diese als OUT deklariert sind.

Danke an alle :-)

> Hat man in der Entity viele STD_LOGIC Pins, und keinen STD_LOGIC_VECTOR,
> so muss man auch in der Architecture jeden Pin einzeln zuweisen wenn
> diese als OUT deklariert sind.

Richtig.

Sowas ist allerdings möglich:

signal a,b,c is std_logic;
signal x is std_logic_vector(2 downto 0);
...
(a,b,c) <= x;
-- oder:
(2 => a, 1 => b, 0 => c) <= x;

Einen std_logic_vector in kleinere aufzuteilen wird damit aber
vermutlich nicht gehen, weil ein langer std_logic_vector nicht das selbe
ist wie ein Array von std_logic_vectors.