SRA kann solche Operanden nicht haben?

Question

Ich habe einen Algorithmus in VHDL codiert, aber ich habe diese Nachricht, die ich nicht verstehe "sra/sla kann solche Operanden in diesem Kontext nicht haben.". Irgendwelche 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 Ganzzahlen müssen Sie die Operatoren * und / verwenden. Wenn sie konstante 2er-Potenzen an den richtigen Stellen haben (dh auf der rechten Seite der Teilung, auf jeder Seite der Multiplikation), wird der Synthesizer "das Richtige tun".

Oder (wie Charles bemerkte) signed oder unsigned Typen von ieee.numeric_std library verwenden.

BTW, warum verwenden Sie conv_std_logic_vector, wenn Sie ieee.numeric_std verwendet haben?

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

sollte das sein, was Sie benötigen, dann können Sie

(Abgesehen loszuwerden, die fiesen ieee.std_logic_arith Bibliothek erhalten: Wenn Sie (oder ein zukünftiger Leser dieser) sind ein FPGA-Targeting (und ich nehme Sie können nicht sein, aber viele Menschen sind heutzutage :) Sie können feststellen, dass es notwendig ist, diese Architektur etwas zu pipelineeren, wenn die Zielfrequenz überhaupt herausfordernd ist. Bei einer kurzen Augapfel-Synthese gibt es mehr als ein halbes Dutzend Addierer, a ein paar echte Multiplizierer und ein paar Muxes - alles in einem einzigen Taktzyklus.Insbesondere schließt dies die Verwendung der harten Multiplizierer in allen FPGAs, die ich kenne, aus

Answer 2

Das Problem ist, dass Sie Ihre std_logic_vector I/O in ganze Zahlen umgewandelt haben Mathematik zu führen, aber die sra/srl Operanden nur auf 1D-Arrays von Bit oder boolean Typen arbeiten. Sie werden wahrscheinlich viel mehr Glück haben, wenn Sie mit signierten oder unsignierten Typen (die Bit-Vektor-Repräsentationen von Zahlen sind) arbeiten, anstatt std_logic_vectors (die keinen inhärenten numerischen Wert haben) und Ganzzahlen (die keine Bit-Vektor-Repräsentation haben) zu mischen.