Lothar Miller - FPGA

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:

Ringoszillator im S3

nospam@example.com (Lothar Miller) — Fri, 06 Mar 2009 08:50:40 +0100

Wie oft braucht man nur einfach irgend einen Takt?
Der muss nicht genau oder stabil sein, sondern einfach nur vor sich hintakten.

Dann ist die gute alte Methode über Gatterlaufzeiten und einen Inverter einen Ringoszillator zu bauen eigentlich naheliegend. Allerdings neigen die Tools beim FPGA-Design zur Optimierung. Hintereinandergeschaltete Gatter werden zusammengefasst, vereinfacht und gehen so im Build-Prozess verloren

Dagegen hilft bei Xilinx das Attribut "KEEP". Auf ein Signal angewandt teilt man der Toolchain mit, dass dieses Signal erhalten bleiben soll. Und das ist der Weg, der für den Ringoszillator beschritten wird.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;


entity RingOszillator is
    Port (reset  : in std_logic;
          oscout : out std_logic);
end RingOszillator;

architecture Behavioral of RingOszillator is
  signal oscff   : std_logic := '0';
  signal ring    : std_logic_vector(7 downto 0);
  attribute KEEP : string; 
  attribute KEEP of ring : signal is "true"; 
begin
  -- die Gatterkette
  ring <= ring(6 downto 0) & not ring(7) when reset='0' else (others=>'0');
  -- das Symmetrier-Flipflop
  process (ring) begin
     if rising_edge(ring(7)) then
        oscff <= not oscff;
     end if;
  end process;
  -- die Ausgangszuweisung
  oscout <= oscff;
end Behavioral;

Der reset ist wichtig, ohne dieses Signal wird die Gatterkette nicht richtig zurückgesetzt, und der Oszillator beginnt nicht zu schwingen.

Mit einem Spartan3 XC3S400 im FG456 Gehäuse erhält man damit eine ziemlich temperaturstabile Frequenz von 50MHz am oscout. Damit lässt sich doch schon arbeiten, oder?

PROG_B und DONE

nospam@example.com (Lothar Miller) — Wed, 12 Nov 2008 18:19:33 +0100

Ein Pin namens DONE zeigt bei Xilinx FPGAs an, ob die Konfiguration geklappt hat, und das FPGA korrekt konfiguriert wurde. Dieser Pin wird auch vom Programmieradapter abgefragt. Geht er nach Abschluss der Programmierung nicht auf HIGH, wertet Impact dies als Fehler und gibt eine entsprechende Warnung aus:

INFO:iMPACT:2219 - Status register values:
INFO:iMPACT - 0000 0000 0000 0000 0000 0000 0000 0000
INFO:iMPACT:579 - '1': Completed downloading bit file to device.
 Match_cycle = NoWait.
Match cycle: NoWait
INFO:iMPACT - '1': Checking done pin....done.
'1': Programming terminated. DONE did not go high.
PROGRESS_END - End Operation.
Elapsed time =      5 sec.

Dies kann u.a. passieren, wenn der PROG_B Pin auf LOW liegt. Dann wird zwar das FPGA als Device von IMPACT richtig erkannt, die ID wird korrekt ausgelesen, aber die Konfiguration schlägt fehl und führt zu obiger Meldung. Das wird im Datenblatt auch extra erläutert:

Abhilfe: der PROG_B Pin bekommt einen 4k7-Pullup nach 2V5.

LED am DONE Pin

Wenn am DONE Pin eine LED angeschlossen ist, die Konfiguration korrekt abläuft, die LED aber nicht lecuhtet, dann könnte ein Häckchen in den Optionen von Generate Programming File (Rechtsklick ==> Properties) bei der Option Drive Done Pin High fehlen:

Alternativ kann auch die Option Configuration Pin Done auf Pull Up gesetzt werden.

Das ist auch die Defaulteinstellung.

RAM

nospam@example.com (Lothar Miller) — Mon, 10 Nov 2008 15:08:00 +0100

Wer mit Xilinx FPGAs anfängt, der braucht früher oder später mal ein RAM.

Jetzt gibt es in diesen FPGAs zwei Möglichkeiten, ein RAM zu realisieren:

1) als Distributed RAM, bei dem (wertvolle) LUTs als 16x1 Speicherblöcke
zusammengeschaltet werden, oder

2) als BRAM (auch Block-RAM genannt), die je nach FPGA unterschiedlich
große synchrone RAM-Blöcke darstellen

Grundsätzlich wird ein RAM als Array in VHDL so beschrieben:

type speicher is array(0 to (2**Addrbreite)-1) of STD_LOGIC_VECTOR(Wortbreite-1 downto 0);
signal memory : speicher;

Wie kann man aber nun, ausgehend von einer generischen Beschreibung eines RAM-Arrays, steuern welchen RAM-Typ man bekommt?

Eigentlich ist es ganz einfach:
Wenn die Lese-Adresse getaktet ist,
dann gibt es synchrones BRAM.

"RAM" vollständig lesen

FIFO

nospam@example.com (Lothar Miller) — Mon, 10 Nov 2008 14:49:15 +0100

FIFO (First-InFirst-Out) sind Pufferspeicher für den Übergang von schnellen Übertragungspfaden auf langsamere (z.B. USB ==> RS232). Hier werden Daten in einen Ringpuffer eingespeichert, und später mit einer niedrigeren Datenrate ausgelesen.

Alternativ können Daten von einem langsamen Medium zwischengespeichert, und dann in einem Paket auf einem schnelleren Datenpfad übertragen werden.

Ein FIFO wird demzufolge am einfachsten über einen 2^n langen Ringspeicher realisiert, der mit 2 Zählern der Breite n adressiert wird. Ist der Schreibzeiger gleich dem Lesezeiger, dann ist der FIFO leer. Erreicht der Schreibzeiger den Wert des Lesezeigers-1, dann ist der FIFO voll, der Schreibzeiger hat den Lesezeiger quasi "von hinten" eingeholt.

"FIFO" vollständig lesen