division von signed

[Hans (Gast)]

Hallo,
ich versuch gerade einen exp. gleitenden Mittelwert zu beschreiben.

 
entity exp_average is
    Port ( clk   : in  STD_LOGIC;
           value   : in  signed (1 downto 0);  -- -1, 0 , +1
           mean   : out signed (31 downto 0));
end exp_average;

architecture Behavioral of exp_average is

  signal state    : std_logic := '0';
  signal exp_mean_a : signed (31 downto 0) := to_signed(0, 32);
  signal exp_mean_b : signed (31  downto 0) := to_signed(0, 32); 

begin

process (clk)
begin
  if rising_edge(clk) then
    
    if state = '0' then
      state <= '1';
      mean <= exp_mean_b srl 12;
      exp_mean_a   <= (exp_mean_b - (exp_mean_b srl 12)) + (resize(signed(value),32) sll 12);
    else
      state <= '0';
      mean <= exp_mean_b srl 12;
      exp_mean_b   <= (exp_mean_a - (exp_mean_a srl 12)) +  (resize(signed(value),32) sll 12);
    end if;
  end if;
end process;

end Behavioral;

Value soll nur die Werte -1, 0, 1 annehmen. Wenn es 1 hat, dann 
konvergiert mean auch schön gegen 4096. Jedoch bei -1 funktioniert, dass 
ganze nicht. Wahrscheinlich liegt es an dem Shiften. Man könnte das 
Shiften durch Multiplikation/Divison ersetzen, aber da müsste man doch 
die Bitzahl des Ergebnisses erweitern? Gibt es eine Möglichkeit das 
Shiften vorzeichen unabhänging durchzuführen?

Mfg
Hans

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

Hans schrieb:
> Wahrscheinlich liegt es an dem Shiften.
Was sagt denn die Simulation?

Das ist die srl in der numeric_std:

  function "srl" (ARG: SIGNED; COUNT: INTEGER) return SIGNED is
  begin
    if (COUNT >= 0) then
      return SIGNED(SHIFT_RIGHT(UNSIGNED(ARG), COUNT));  -- hoppala, da wird unsigned geshiftet!!
    else
      return SHIFT_LEFT(ARG, -COUNT);
    end if;
  end "srl";

Nimm besser gleich die SHIFT_RIGHT:

  function SHIFT_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED is
  begin
    if (ARG'LENGTH < 1) then return NAS;
    end if;
    return SIGNED(XSRA(STD_LOGIC_VECTOR(ARG), COUNT));
  end SHIFT_RIGHT;

  function XSRA (ARG: STD_LOGIC_VECTOR; COUNT: NATURAL) return STD_LOGIC_VECTOR
      is
    constant ARG_L: INTEGER := ARG'LENGTH-1;
    alias XARG: STD_LOGIC_VECTOR(ARG_L downto 0) is ARG;
    variable RESULT: STD_LOGIC_VECTOR(ARG_L downto 0);
    variable XCOUNT: NATURAL := COUNT;
  begin
    if ((ARG'LENGTH <= 1) or (XCOUNT = 0)) then return ARG;
    else
      if (XCOUNT > ARG_L) then XCOUNT := ARG_L;
      end if;
      RESULT(ARG_L-XCOUNT downto 0) := XARG(ARG_L downto XCOUNT);
      RESULT(ARG_L downto (ARG_L - XCOUNT + 1)) := (others => XARG(ARG_L)); -- hier ist die Vorzeichenerweiterung
    end if;
    return RESULT;
  end XSRA;

Allerdings solltest du aufassen: die Division einer negativen Zahl durch 
2 ist nicht das selbe wie ein Rechtsshift einer negativen Zahl um 1.