© photocase.com

Der Weg zu Ihrem ersten eigenen Schaltkreis ist gut gepflastert, denn die kostenlosen Entwicklungsumgebungen der Chiphersteller und günstige Starter Kits ermöglichen sogar Privatleuten den Einstieg in die professionelle Programmierung der Gate-Arrays.

Die programmierbaren Logik-Bausteine (FPGA, Field Programmable Gate Array) spielen in der Schaltungsentwicklung eine große Rolle: Sie bestehen aus verschiedenen Funktionseinheiten, die der Entwickler über eine Konfigurationsdatei miteinander verknüpft. Auf diese Weise können FPGAs die Funktionen hochspezialisierter Mikrochips emulieren, die erst zu einem späteren Zeitpunkt überhaupt gefertigt werden – bei Kleinserien oder Einzelprojekten rechnet es sich oft sogar, an Stelle eines anwendungsspezifischen Chips einfach einen leistungsfähigen FPGA einzusetzen.

Kostengünstiger Einstieg

Die Preise für FPGAs, zum Beispiel der Spartan-3-Familie von Xilinx [1], sind je nach Anzahl der Gatter mit zwei bis 50 US-Dollar nicht nur für die Industrie, sondern auch für private Entwickler durchaus erschwinglich. Selbst das Starter Kit (Abbildung 1) von Digilent [2], das neben dem FPGA diverse Schnittstellen, Schalter und LEDs auf einem System Development Board vereint, kostet nur 100 US-Dollar. Genauere Informationen zum Starter Kit stehen im Kasten “Hardware für die Entwicklung”.

Hardware für die Entwicklung

Für den einfachen Schaltungsentwurf bieten etliche Hersteller Starter Kits oder Prototyping Boards mit verschiedenen FPGAs an. Allen gemeinsam ist, dass sie neben dem FPGA noch zusätzliche Komponenten wie USB-Controller, LEDs, Taster, Flashspeicher und eine Vielzahl von Schnittstellen besitzen. Das Starter Kit mit integriertem Spartan-3-FPGA von Digilent [2] ist mit 100 US-Dollar besonders günstig (Abbildung 1). Der Autor dieses Artikels setzt das auch von Xilinx direkt vertriebene Board mit der Bezeichnung DO-SPAR3-DK sowohl privat als auch beruflich ein. Neben dem Spartan 3 mit 200000 Gatter-Äquivalenten besitzt das Board ein 2 MBit großes Konfigurations-PROM, 1 MByte SRAM, einen VGA-Anschluss, eine serielle Schnittstelle, einen PS/2-Anschluss, vier Sieben-Segment-Anzeigen, acht Schalter, acht LEDs, vier Taster, einen 50-MHz-Quarz sowie drei Anschlussleisten mit diversen Signalen. Zudem ist im Lieferumfang ein Download-Kabel enthalten, das zur Übertragung der Konfigurationsdaten zwischen FPGA und PC dient. Abbildung 1: Das Starter Kit enthält neben dem FPGA (1) einen 2-MBit-Flash (2), Schnittstellen für PS/2 (3), VGA (4) und RS-232 (5), vier Taster (6), acht Schalter (7) und LEDs (8) sowie vier Sieben-Segment-Anzeigen.

Der Aufbau des Spartan-3-FPGA von Xilinx ähnelt sehr den FPGAs anderer Hersteller: Der Chip besitzt eine Anzahl Funktions- und Logikblöcke, die eine veränderliche Programmierung miteinander verbindet. Abbildung 2 zeigt den schematischen Aufbau des Spartan 3: In der Mitte sitzen die grün unterlegten Configurable Logic Blocks (CLB), umrandet von den rot gefärbten Input/Output Blocks (IOB).

Abbildung 2: Der FPGA besteht aus einzelnen Logikblöcken, die durch eine veränderliche Programmierung miteinander verbunden sind. Die Entwicklungswerkzeuge arbeiten die Verdrahtung für die einzelnen Blöcke aus.

Für die Signalübertragung zwischen den Blöcken sorgt eine Hierarchie von Verdrahtungsressourcen (Routing Resources). Der Spartan 3 besitzt noch weitere Funktionseinheiten, etwa Speicherblöcke (Block RAM, lila) zur Datenspeicherung auf dem FPGA sowie die Taktgeneratoren (Digital Clock Manager, DCM, gelb), die die Taktsignale beeinflussen können. Selbst beschleunigte arithmetische Funktionen stellt der Spartan bereit, etwa mit den blauen Hardware-Multiplizierern. Weitere Details zum Spartan 3 liefern die Application Notes [4] von Xilinx.

Der Entwickler beschreibt die Schaltung und ihre Funktion zunächst mit Hilfe der standardisierten Hardware Description Language (HDL). Die Abbildung der Schaltung auf die Funktionsblöcke des FPGA und deren Verdrahtung untereinander übernehmen anschließend die Entwicklungswerkzeuge der Hersteller. Noch vor ein paar Jahren konnten sich nur Firmen solche Entwicklungsumgebungen leisten, heute bieten viele FPGA-Hersteller entsprechende Linux-Programme kostenfrei zum Download an.

IDE installieren

Das ISE Webpack (Version 8.1i, [6]) von Xilinx vereint Projektverwaltung, Synthesewerkzeug, HDL- und Schaltungseditor unter einer Oberfläche. Auch die Übertragung der fertigen Konfigurationsdatei (Bitstream) zum FPGA übernimmt ein Programm des Pakets.

Nach kostenloser Registrierung bei Xilinx können Sie die Entwicklungsumgebung auf zwei Arten installieren: Über den ISE-Web-Installer, der eine Internetverbindung erfordert und die übrigen Teile des knapp 900 MByte großen Softwarepakets eigenständig herunterlädt, oder durch Download des Komplettpakets. Die Software eignet sich sowohl für 32- als auch 64-Bit-Systeme und wurde für Fedora Core 3 und 4 zusammengestellt. Sie funktioniert auch mit anderen Linux-Systemen, setzt jedoch voraus, dass Open Motif bereits installiert ist.

Bei manchen Systemen scheitert das Installationsprogramm an der Bestimmung der Kernelversion. Ist dies der Fall, setzen Sie die Umgebungsvariable »LD_ASSUME_KERNEL=2.4.7« und starten die Installation erneut. Probleme mit nicht ausführbaren Dateien können Sie vorerst ignorieren.

Gleich nach der Installation sollten Sie im Download-Bereich von [1] nach Updates suchen. Die stellt Xilinx als Zip-Datei zur Verfügung, die Sie lediglich auspacken und dann das enthaltene Setup-Programm aufrufen. Alle weiteren Schritte übernimmt »setup«. Erst nach dem Update starten Sie die Entwicklungsumgebung »ise«.

Die schrittweise Entwicklung eines Hardware-Entwurfs mit festgelegten Schritten wird als Entwurfsablauf (Design Flow) bezeichnet (Abbildung 3). Das Ablaufdiagramm zeigt deutlich, dass der Simulator das zentrale Kontrollwerkzeug für alle Entwicklungsstufen ist.

Abbildung 3: Der Entwurfsablauf für die FPGA-Entwicklung zeigt, dass der Simulator jede Entwicklungsstufe verifiziert, bevor der nächste Schritt folgt. Zum Schluss entsteht die Konfigurationsdatei für den FPGA.

Erster Entwurf

Für die Schaltungseingabe im ersten Schritt des Entwurfsablaufs stellt die Xilinx-Entwurfsumgebung verschiedene Wege zur Wahl. Möglich sind ein Schaltplan-basierter Entwurf, ein grafischer Automatenentwurf und die Verwendung von Hardware-Beschreibungssprachen wie VHDL (Very High Speed Integrated Circuit Hardware Description Language) oder Verilog. Die Hardware-Beschreibung in VHDL hat sich als Standard durchgesetzt. Die ISE von Xilinx besitzt dafür einen integrierten Editor (Abbildung 4) mit Syntax-Highlighting und Templates. Haben Sie die Entwurfsbeschreibung fertig gestellt, überprüfen Sie sie mit dem VHDL-Simulator.

Abbildung 4: Die integrierte Entwicklungsumgebung ISE von Xilinx enthält neben der Projektverwaltung im linken Teil des Fensters auch einen VHDL-Editor mit Syntax-Highlighting.

Die Simulation ist ein wichtiger Teil, da sich hier mögliche Design-Fehler zeigen. Dafür hat Xilinx ab der Version 8.1 der Entwicklungsumgebung ISE einen HDL-Simulator integriert, den Sie gegen Simulatoren anderer Hersteller austauschen können, beispielsweise VHDL Simili 3.0 von Symphony EDA [7], falls Sie einmal keine Xilinx-FPGAs einsetzen.

War die Simulation erfolgreich, übersetzen Sie die Schaltungsbeschreibung über das Synthesemodul in eine Netzliste für den FPGA. Dabei bildet der Synthesizer die VHDL-Befehle auf generische Hardware-Elemente ab, die noch keinen technischen Bezug zum späteren FPGA haben. Erst im nächsten Schritt – Place & Route – erfolgt mit Hilfe der Technologie-Bibliotheken des jeweiligen FPGA die virtuelle Verdrahtung der einzelnen Funktions- und Logikblöcke miteinander. Das Timing innerhalb des FPGA können Sie an dieser Stelle durch eine erneute Simulation überprüfen.

Beim letzten Schritt erzeugen Sie die Konfigurationsdatei (Bitstream), die dann nur noch zu Ihrem FPGA passt. Das Programm »impact« überträgt schließlich den Bitstream über das Programmierkabel vom PC zum FPGA. Der Entwurfprozess lässt sich am besten an einem kleinen Beispiel verstehen, etwa einem 8-Bit-Binärzähler. Für die Ausgabe verwenden Sie die acht LEDs LD0 bis LD7, mit denen das Development Board bereits bestückt ist. Weiterhin soll der Zähler wieder bei 0 beginnen, wenn entweder alle 8 Bits gesetzt sind oder wenn Sie [Reset] drücken.

8-Bit-Hardware-Zähler

Der Entwurf beginnt damit, dass Sie in der ISE-Entwicklungsumgebung über »File | New Project…« ein Projekt anlegen. Die Schaltungsbeschreibung soll in VHDL erfolgen, weshalb Sie als »Top Level Source Type« »HDL« wählen. Die folgenden Dialoge beim Anlegen des neuen Projekts beziehen sich auf den von Ihnen verwendeten FPGA-Typ.

Bei dem hier verwendeten System Development Board handelt es sich um einen Spartan 3 mit 200000 Gatteräquivalenten und der Bezeichnung »xc3s200« im »ft256«-Gehäuse. Für das sehr überschaubare Zähler-Projekt verwenden Sie das Synthese-Tool XST und den ISE-Simulator für VHDL sowie Verilog, um den VHDL-Entwurf zu verarbeiten. Zudem sollten Sie die Option »Enable Enhanced Design Summary« aktivieren.

Bei jedem neuen Projekt sind sowohl das Menü für das Quelldateien-Management als auch die Entwurfsablauf-Verwaltung im linken Teil der ISE-Entwicklungsumgebung zu finden, wie in Abbildung 4 zu sehen. Zunächst müssen Sie im »Processes«-Fenster links in der Mitte dieser Abbildung »Create New Source« doppelklicken und damit ein VHDL-Modul anlegen. Es erscheint dann im Quellbereich links oben.

Das VHDL-Programm des Binärzählers in Listing 1 besteht aus drei Teilen: dem Kopf mit den Bibliotheken, dem »entity«-Abschnitt, der die Schnittstellen zur Außenwelt beschreibt, und dem »architecture«-Block mit dem inneren Aufbau des Zählers. Im »entity«-Block definieren die Angaben »in« und »out« die Ein- und Ausgänge, die der FPGA später verwendet. Zu den Eingangssignalen zählen auch das Reset-Signal »reset« sowie das Taktsignal »clk_50mhz«. Die Ausgabe erfolgt über die acht LEDs – die Angabe »7 downto 0« legt fest, dass das niederwertigste Bit rechts angezeigt wird.

01 library ieee;
02 use ieee.std_logic_1164.all;
03 use ieee.std_logic_arith.all;
04 use ieee.std_logic_unsigned.all;
05 
06 entity counter is
07   port (clk_50mhz : in  std_logic;
08           reset   : in  std_logic;
09           led     : out std_logic_vector(7 downto 0));
10 end counter;
11 
12 architecture behavioral of counter is
13   signal sig_ctr   : std_logic_vector(7 downto 0) := "00000000";
14   signal clk       : std_logic;
15   signal clk_div   : std_logic;
16 begin
17 
18   clk_div <= clk_50mhz;
19 
20   count : process (clk_div, reset)
21   begin
22     if (reset = '1') then
23       sig_ctr<="11111111";
24     elsif (clk_div'event) and (clk_div='1') then
25       sig_ctr<= sig_ctr + 1;
26     end if;
27   end process count;
28 
29   led <= sig_ctr;
30 end behavioral;

Die Funktionsbeschreibung des Zählers steht im »architecture«-Abschnitt. Sie enthält einen »process«-Block mit Namen »count«, der auf die Signale »reset« und »clk_div« reagiert, also den Reset-Taster und das Taktsignal. »count« sorgt dafür, dass der Spartan bei [Reset] den Zähler neu initialisiert (Zeile 23) und ansonsten bei jedem Takt den Wert um eins erhöht (Zeile 25). Zeile 29 zeigt den aktuellen Zählerstand über die LEDs an.

VHDL-Simulation

Nachdem Sie die Arbeitsweise des Zählers beschrieben haben, folgt die Simulation. Dazu müssen Sie geeignete Testsätze an das Testobjekt (UUT, Unit Under Test) anlegen. Die ISE-Entwicklungsumgebung kann dies übernehmen und automatisieren, indem Sie eine Testumgebung entwerfen. Dazu wählen Sie im Management-Fenster links oben unter »Sources for:« den Eintrag »Behavioral Simulation« und klicken im »Processes«-Fenster links in der Mitte zweimal auf »Create New Source« – ISE legt daraufhin die Testbench-Datei vom Typ »VHDL Test Bench« an. Sie enthält automatisch eine für den Zähler geeignete, allerdings noch leere VHDL-Testbench, wie in Listing 2 zu sehen.

01 tb : PROCESS
02 BEGIN
03 -- Wait 100 ns for global reset to finish
04   wait for 100 ns;
05   -- Place stimulus here
06   wait; -- will wait forever
07 END PROCESS;

Der Binärzähler benötigt für den Betrieb lediglich ein Taktsignal, außerdem kann er auf ein Reset-Signal reagieren. Sie erzeugen also in der Testbench ein fortlaufendes Taktsignal und lassen die Reset-Leitung auf 100 Nanosekunden gesetzt, bevor der Zähler startet. Die passenden VHDL-Anweisungen dazu enthält Listing 3, Sie müssen die beiden Abschnitte nur in die Testbench integrieren.

01 RESET_GENERATOR: process
02 begin
03   reset <= '1';
04   wait for 100 ns;
05   reset <= '0';
06   wait for 1 us;
07   wait;
08 end process;
09 
10 CLK_GENERATOR: process
11 begin
12   clk_50mhz <= '0';
13   wait for 20 ns;
14   clk_50mhz <= '1';
15   wait for 20 ns;
16 end process;

Mit der vollständigen Testbench können Sie die Funktion des FPGA nunmehr simulieren. Den in ISE integrierten Simulator finden Sie im »Processes«-Fenster unter »Xilinx ISE Simulator«; Sie können ihn einmal als Syntax-Checker verwenden oder mit »Simulate Behavioral Model« als Simulator aufrufen.

Erfolgskontrolle

Die Standarddauer der Simulation beträgt 1000 Nanosekunden, Sie können die Laufzeit aber in der unteren Toolbar (Abbildung 5) beliebig erhöhen – zum Beispiel auf 9350 Nanosekunden, die die Schaltung für einen kompletten Zählerdurchlauf benötigt. Mit einem Doppelklick auf »Simulate Behavioral Model« im »Processes«-Fenster öffnet sich ein neues Fenster mit dem Ergebnis der Simulation (Abbildung 5 rechts).

Abbildung 5: Mit Hilfe der Simulation überprüfen Sie Ihren Hardware-Entwurf nicht nur auf seine korrekte Funktion, sondern auch auf das Timing-Verhalten (rechts). Die Dauer des Testlaufs lässt sich dazu über die untere Werkzeugleiste je nach Bedarf einstellen.

Wenn der Zähler in der Simulation einwandfrei funktioniert, überführen Sie den VHDL-Code mit dem Synthesizer in eine Netzliste und dann in den Bitstream. Dazu doppelklicken Sie im »Processes«-Fenster erst »Synthesize – XST«, dann »Implement Design« und schließlich »Generate Programming File«. Etwaige Fehlermeldungen finden Sie im »Console«-Fenster unten im ISE.

Dort steht auch, welche Hardware-Ressourcen Ihr Programmentwurf benötigt – beim Binärzähler sind das 6 von 1920 Slices mit je zwei CLBs sowie 8 von 3840 Flip-Flops des Spartan. Damit die LEDs des Starter Kit bei einem Takt von 50 MHz überhaupt leuchten, schrauben Sie den Zähltakt von 50 MHz deutlich herunter. Dazu fügen Sie einen »delay«-Prozess in die VHDL-Programmbeschreibung ein. Listing 4 zeigt lediglich den »architecture«-Block mit den entsprechenden Änderungen.

01 architecture behavioral of counter is
02   signal sig_ctr   : std_logic_vector(7  downto 0) := "00000000";
03   signal delay_ctr : std_logic_vector(25 downto 0)
04                    := "00000000000000000000000000";
05   signal clk       : std_logic;
06   signal clk_div   : std_logic;
07 
08 begin
09 
10   delay: process (clk_50mhz, reset)
11   begin
12     if (reset = '1') then
13       delay_ctr<="00000000000000000000000000";
14     elsif (clk_50mhz'event) and (clk_50mhz='1') then
15       delay_ctr<=delay_ctr+"00000000000000000000000001";
16 
17       if delay_ctr="00001011111010111100001000" then
18         delay_ctr<="00000000000000000000000000";
19         clk_div <= '1';
20       else
21         clk_div <= '0';
22       end if;
23 
24     end if;
25   end process delay;
26 
27   count : process (clk_div, reset)
28   begin
29     if (reset = '1') then
30       sig_ctr<="11111111";
31     elsif (clk_div'event) and (clk_div='1') then
32       sig_ctr<= sig_ctr + 1;
33     end if;
34   end process count;
35 
36   led <= sig_ctr;
37 end behavioral;

Jetzt müssen Sie dem FPGA mitteilen, an welchen Pins konkret das Taktsignal, der [Reset]-Taster und die LEDs angeschlossen sind. Dies übernimmt das User Constraint File (UCF). Um die Datei anzulegen, öffnen Sie die VHDL-Quellen des Projekts und wählen »New Source…«, der Dateityp lautet diesmal »Implementation Constraints File«.

Listing 5 enthält die Definitionen des User Constraint Files, die Sie im Editor eingeben. Neben der Zuweisung der Pins legen die einzelnen Zeilen auch die Signalpegel auf 3,3 Volt fest. Zum Abschluss erzeugen Sie den Bitstream noch einmal neu, damit er auch die Pinbelegungen enthält.

01 NET "clk_50mhz" LOC = "T9"  | IOSTANDARD = LVCMOS33 ;
02 NET "reset"     LOC = "L14" | IOSTANDARD = LVCMOS33 ;
03 NET "led<0>"    LOC = "K12" | IOSTANDARD = LVCMOS33 ;
04 NET "led<1>"    LOC = "P14" | IOSTANDARD = LVCMOS33 ;
05 NET "led<2>"    LOC = "L12" | IOSTANDARD = LVCMOS33 ;
06 NET "led<3>"    LOC = "N14" | IOSTANDARD = LVCMOS33 ;
07 NET "led<4>"    LOC = "P13" | IOSTANDARD = LVCMOS33 ;
08 NET "led<5>"    LOC = "N12" | IOSTANDARD = LVCMOS33 ;
09 NET "led<6>"    LOC = "P12" | IOSTANDARD = LVCMOS33 ;
10 NET "led<7>"    LOC = "P11" | IOSTANDARD = LVCMOS33 ;

In Silizium schreiben

Der fertige Bitstream, also die Konfigurationsdatei des FPGA, gelangt mit Hilfe von »impact«, das im ISE Webpack enthalten ist, über das Programmierkabel des Starter Kit auf den Spartan. Sie finden das Programm im »Processes«-Fenster unter »Generating Programming File | Configure Device (iMPACT)«. Die Programmiersoftware erkennt den angeschlossenen FPGA automatisch.

Sollte sich »impact« jedoch beschweren, dass der »windrvr6«-Treiber nicht vorhanden ist, müssen Sie ihn von [9] manuell übersetzen und installieren. Achten Sie darauf, dass nach der Einrichtung »/dev/windrvr6« für alle Benutzer les-, schreib- und ausführbar ist. Impact zeigt im Programmfenster bei angeschlossenem Starter Kit gleich zwei programmierbare Bausteine an – einmal den Spartan und einmal das auf dem Starter Kit enthaltene Konfigurations-PROM. Den Bitstream sollten Sie direkt in den Spartan laden.

Für die Übertragung des Bitstream doppelklicken Sie zunächst den FPGA und wählen als Datei »counter.bit«. Ein Klick mit der rechten Maustaste auf den FPGA öffnet ein Kontextmenü, aus dem Sie »Program…« auswählen und die Datenübertragung mit »ok« anstoßen. Der Transfer dauert einige Sekunden. Ist der Bitstream übertragen, beginnt der Spartan automatisch mit dem Zählen.

Hardware-Entwicklung zum kleinen Preis

Mit dem ISE Webpack von Xilinx ist die FPGA-Entwicklung und Programmierung fast zum Taschengeld-Tarif möglich, ein System Development Board für rund 100 US-Dollar ergänzt die Software zu einer vollwertigen FPGA-Prototyping-Umgebung, in der Sie auch komplexe Hardware-Entwürfe testen können.

Ist das Design reif für die erste Kleinserie, sind die Spartan-FPGAs die einzige günstige Alternative zu anwendungsspezifischen Mikrochips – die auf dem System Development Board getesteten VHDL-Beschreibungen lassen sich dann problemlos auch auf die kleineren Spartan-FPGAs ab zwei US-Dollar das Stück übertragen. Wer aber das nötige Kleingeld besitzt, der kann den VHDL-Entwurf als Ausgangsbasis für einen maßgeschneiderten Chip verwenden, die meist ebenfalls in VHDL beschrieben wird. Dann ist der Spartan nur ein Meilenstein auf dem Entwicklungsweg. (mdö)