DDFS mit BROM

nospam@example.com (Lothar Miller) — Wed, 01 Apr 2009 13:06:00 +0200

Ein Direct Digital Frequency Synthesizer liest aus einer Tabelle Werte aus, und gibt die an einen DA-Wandler. Damit können dann die wildesten Kurvenformen erzeugt werden. Wenn ich aber "nur" einen ordinären Sinus will, reicht es aus, den ersten Quadranten im RAM zu speichern und daraus die anderen drei zu berechnen.

Genau das macht dieser VHDL-Code: in einem BRAM im FPGA wird das erste Viertel einer Sinusschwingung abgelegt, und dann abhängig vom Quadranten vorwärts oder rückwärts ausgelesen und bei Bedarf invertiert.

library IEEE;
  use IEEE.std_logic_1164.all;
  use IEEE.numeric_std.all;
--------------------------------------------------
Entity DDFS is
--------------------------------------------------
   Port ( CLK       : in  std_logic;
          Freq_Data : in  std_logic_vector (7 downto 0);
          Dout      : out std_logic_vector (7 downto 0)
        );
   end DDFS;
--------------------------------------------------
Architecture RTL of DDFS is
--------------------------------------------------
  signal Result   : signed (7 downto 0);
  signal Accum    : unsigned (20 downto 0) := (others=>'0'); 
  signal Address  : integer range 0 to 63;
  signal RomAddr  : integer range 0 to 63;
  signal Quadrant : std_logic; 
  signal Sign     : std_logic; 

  type Rom64x8 is array (0 to 63) of signed (7 downto 0); 
  -- Sinus von 0° bis 90° (0 bis PI/2)
  constant Sinus_Rom : Rom64x8 := (
    x"00",  x"03",  x"06",  x"09",  x"0c",  x"0f",  x"12",  x"15",
    x"18",  x"1b",  x"1e",  x"21",  x"24",  x"27",  x"2a",  x"2d",
    x"30",  x"33",  x"36",  x"39",  x"3b",  x"3e",  x"41",  x"43",
    x"46",  x"49",  x"4b",  x"4e",  x"50",  x"52",  x"55",  x"57",
    x"59",  x"5b",  x"5e",  x"60",  x"62",  x"64",  x"66",  x"67",
    x"69",  x"6b",  x"6c",  x"6e",  x"70",  x"71",  x"72",  x"74",
    x"75",  x"76",  x"77",  x"78",  x"79",  x"7a",  x"7b",  x"7b",
    x"7c",  x"7d",  x"7d",  x"7e",  x"7e",  x"7e",  x"7f",  x"7f");
begin
   -- Phasenakkumulator   
   process begin
     wait until rising_edge(CLK);
     Accum <= Accum + unsigned(Freq_Data);
   end process;

   -- BROM      
   process begin
     wait until rising_edge(CLK);
     RomAddr <= Address;          -- getaktete Adresse --> BRAM
   end process;
   Result   <= signed(Sinus_Rom(RomAddr));

   Quadrant <= Accum(Accum'left-1);
   Address  <=    to_integer(Accum(Accum'high-2 downto Accum'high-7))  when (Quadrant='0') else 
               63-to_integer(Accum(Accum'high-2 downto Accum'high-7));
 
   -- 1 Takt Latency wegen BROM
   process begin
     wait until rising_edge(CLK);
     Sign    <= Accum(Accum'left);
   end process;
   Dout     <= std_logic_vector(  Result)   when (Sign='1') else  
               std_logic_vector(0-Result);
end RTL;

Wird die Fließkommalibrary IEEE.math_real verwendet, dann kann man sich die Sinustabelle auch einfach vom Synthesizer ausrechnen lassen. Hier wird nur ein Viertel des Sinus ausgerechnet (und dann bei der Ausgabe gedreht und gespiegelt), deshalb der Offset von 1.0:

  use ieee.math_real.all;  
:
  type Rom64x8 is array (0 to 63) of signed (7 downto 0); 
  -- Sinus von 0° bis 90° (0 bis PI/2)
  signal Sinus_Rom : Rom64x8;
:
   table: for i in 0 to 63 generate
       Sinus_Rom(i) <= to_signed(integer( ( sin(2.0*MATH_PI*real(i)/255.0) +1.0) 127.5 ),8);
   end generate;

Ein ganzer Sinus wird so dargestellt:

   table: for i in 0 to 255 generate
       Sinus_Rom(i) <= to_signed(integer(   sin(2.0*MATH_PI*real(i)/255.0)       *127.5 -0.5 ),8);
   end generate;

DDFS mit Distributed ROM

nospam@example.com (Lothar Miller) — Wed, 01 Apr 2009 12:56:42 +0200

Der DDF Snthesizer mit BROM ist schön, wenn man noch übrige BRAMs hat. Alternativ kann auch ein distributed ROM verwendet werden. Dann werden LUTs als 16x1 Speicherzellen verwendet.

library IEEE;
  use IEEE.std_logic_1164.all;
  use IEEE.numeric_std.all;
-- -----------------------------------------------
Entity DDFS is
-- -----------------------------------------------
   Port ( CLK       : in  std_logic;
          Freq_Data : in  std_logic_vector (7 downto 0);
          Dout      : out std_logic_vector (7 downto 0)
        );
   end DDFS;
-- -----------------------------------------------
Architecture RTL of DDFS is
-- -----------------------------------------------
  signal Data     : std_logic_vector (7 downto 0);
  signal Result   : std_logic_vector (7 downto 0);
  signal Accum    : unsigned (20 downto 0) := (others=>'0'); 
  alias  Address  : unsigned (5 downto 0) is Accum(Accum'high-2 downto Accum'high-7);
  alias  Sign     : std_logic is Accum(Accum'high);   -- MSB
  alias  Quadrant : std_logic is Accum(Accum'high-1); 
begin
   -- Phasenakkumulator   
   process begin
     wait until rising_edge(CLK);
     Accum <= Accum + unsigned(Freq_Data); 
   end process;
 
   process (Sign,Quadrant,Address)
     subtype SLV8 is std_logic_vector (7 downto 0);
     type Rom64x8 is array (0 to 63) of SLV8; 
     constant Sinus_Rom : Rom64x8 := (
       x"00",  x"03",  x"06",  x"09",  x"0c",  x"0f",  x"12",  x"15",
       x"18",  x"1b",  x"1e",  x"21",  x"24",  x"27",  x"2a",  x"2d",
       x"30",  x"33",  x"36",  x"39",  x"3b",  x"3e",  x"41",  x"43",
       x"46",  x"49",  x"4b",  x"4e",  x"50",  x"52",  x"55",  x"57",
       x"59",  x"5b",  x"5e",  x"60",  x"62",  x"64",  x"66",  x"67",
       x"69",  x"6b",  x"6c",  x"6e",  x"70",  x"71",  x"72",  x"74",
       x"75",  x"76",  x"77",  x"78",  x"79",  x"7a",  x"7b",  x"7b",
       x"7c",  x"7d",  x"7d",  x"7e",  x"7e",  x"7e",  x"7f",  x"7f");
   begin
     if(Quadrant='0') 
     then Result <= Sinus_Rom (   to_integer(Address));
     else Result <= Sinus_Rom (63-to_integer(Address));
     end if;
     if (Sign='1') 
     then Data <= Result;
     else Data <= std_logic_vector (-signed(Result));
     end if;
   end process;

   process begin
     wait until rising_edge(CLK);
     Dout <= Data;
   end process;
end RTL;

Durch die Verwendung von LUTs ist natürlich der Ressourcenverbrauch im FPGA höher, allerdings ist diese Beschreibung ohne weiteres auf andere FPGAs übertragbar.

Beide Beschreibungen erzeugen aus dem Viertel-Sinus eine wunderhübsche Sinuskurve:

Lothar Miller - DDFS

DDFS mit BROM

DDFS mit Distributed ROM