SRA kann keine solchen Operanden haben?

Question

Ich habe einen Algorithmus in VHDL kodiert, aber ich habe diese Meldung, die ich nicht verstehe: "sra/sla kann solche Operanden in diesem Kontext nicht haben.". Jede Hilfe bitte?

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use ieee.std_logic_arith.conv_std_logic_vector;

entity hsl2rgb is
    generic(
        constant hue : integer := 85;
        constant sat : integer := 127
    );
    port(
        lum    : in  std_logic_vector(7 downto 0);
        ored   : out std_logic_vector(5 downto 0);
        ogreen : out std_logic_vector(5 downto 0);
        oblue  : out std_logic_vector(5 downto 0)
    );
end entity;

architecture behavioral of hsl2rgb is
begin

    process(lum)
        variable v : integer;
        variable m : integer;
        variable sextant : integer;
        variable fract : integer;
        variable vsf : integer;
        variable mid1 : integer;
        variable mid2 : integer;
        variable lumx : integer;
    begin
        lumx := to_integer(unsigned(lum));
        if (lumx < 127) then
            v := (lumx * (256 + sat)) sra 8;
        else
            v := (((lumx + sat) sla 8) - lumx * sat) sla 8;
        end if;

        if (v <= 0) then
            ored <= (others => '0');
            ogreen <= (others => '0');
            oblue <= (others => '0');
        else
            m := (2 * lumx) - v;
            sextant := (hue * 6) sra 8;
            fract := (hue * 6) - (sextant sla 8);
            vsf := (fract * (v - m)) sra 8;
            mid1 := m + vsf;
            mid2 := v - vsf;

            case sextant is
                when 0 =>
                    ored <= conv_std_logic_vector(v, 6);
                    ogreen <= conv_std_logic_vector(mid1, 6);
                    oblue <= conv_std_logic_vector(m, 6);
                when 1 =>
                    ored <= conv_std_logic_vector(mid2, 6);
                    ogreen <= conv_std_logic_vector(v, 6);
                    oblue <= conv_std_logic_vector(m, 6);
                when 2 =>
                    ored <= conv_std_logic_vector(m, 6);
                    ogreen <= conv_std_logic_vector(v, 6);
                    oblue <= conv_std_logic_vector(mid1, 6);
                when 3 =>
                    ored <= conv_std_logic_vector(m, 6);
                    ogreen <= conv_std_logic_vector(mid2, 6);
                    oblue <= conv_std_logic_vector(v, 6);
                when 4 =>
                    ored <= conv_std_logic_vector(mid1, 6);
                    ogreen <= conv_std_logic_vector(m, 6);
                    oblue <= conv_std_logic_vector(v, 6);
                when 5 =>
                    ored <= conv_std_logic_vector(v, 6);
                    ogreen <= conv_std_logic_vector(m, 6);
                    oblue <= conv_std_logic_vector(mid2, 6);
                when others =>
                    ored <= (others => '0');
                    ogreen <= (others => '0');
                    oblue <= (others => '0');
            end case;
        end if;
    end process;
end architecture;

Answer 1

Bei ganzen Zahlen müssen Sie die Funktion * y / Betreiber. Wenn sie konstante Zweierpotenzen an den richtigen Stellen haben (d.h. rechts vom Divide, auf beiden Seiten des Multiplikators), wird der Synthesizer "das Richtige tun".

Oder (wie Charles bemerkte) verwenden Sie signed ou unsigned Typen aus dem ieee.numeric_std library .

Übrigens, warum verwenden Sie conv_std_logic_vector wenn Sie Folgendes verwendet haben ieee.numeric_std ?

ored <= std_logic_vector(to_unsigned(mid1, 6));

die Sie benötigen, dann können Sie die lästigen ieee.std_logic_arith Bibliothek

(Nebenbei bemerkt: Wenn Sie (oder ein zukünftiger Leser dieses Artikels) ein FPGA anstreben (und ich akzeptiere, dass Sie das vielleicht nicht tun, aber viele Leute tun das heutzutage:), werden Sie feststellen, dass es notwendig ist, diese Architektur etwas zu pipelinen, wenn die Zielfrequenz überhaupt eine Herausforderung darstellt. Bei einer kurzen Eyeball-Synthese gibt es mehr als ein halbes Dutzend Addierer, ein paar echte Multiplizierer und ein paar Muxer - alles in einem einzigen Taktzyklus. Dies schließt insbesondere die Verwendung der harten Multiplizierer in allen mir bekannten FPGAs aus.)

Answer 2

Das Problem ist, dass Sie Ihre std_logic_vector E/A in Ganzzahlen umgewandelt haben, um Mathematik durchzuführen, aber die sra/srl-Operanden funktionieren nur auf 1D-Arrays von Bit- oder boolschen Typen. Sie werden wahrscheinlich viel mehr Glück haben, wenn Sie mit vorzeichenbehafteten oder vorzeichenlosen Typen arbeiten (die Bit-Vektor-Darstellungen von Zahlen sind), anstatt std_logic_vectors (die keinen inhärenten numerischen Wert haben) und Integers (die keine Bit-Vektor-Darstellung haben) zu mischen.