Rob's web

Ontwerp je eigen chip

Deel II - CPLD's in de praktijk

Na de hardware-beschrijving van vorige maand gaan we nu aan de slag met het experimenteerbord. We gaan ervan uit dat de software van Altera al geïnstalleerd is en dat u de tutorial heeft gelezen.

Het ontwerpen van digitiale schakelingen komt er meestal op neer dat de beoogde functie steeds wordt opgesplitst in kleinere deelproblemen, net zo lang totdat er een ontwerp uit rolt dat bestaat uit de diverse logische basisfuncties. Van daaruit wordt dan een elektronische schakeling en eventueel ook een print ontworpen.

Beschrijvende talen

Het ontwerpen van digitale schakelingen gaat gemakkelijker indien men gebruik maakt van een beschrijvende taal. De doelstelling van zo'n taal is om een bepaalde functionaliteit te kunnen beschrijven (vandaar ook de naam). Intelligente software is dan in staat om een elektronische schakeling te ontwerpen die voldoet aan de beschrijving die de ontwerper heeft gespecificeerd.

Er bestaan tegenwoordig verschillende beschrijvende talen. Twee van deze talen zijn fabrikant-onafhankelijk en deze worden goed ondersteund door veel fabrikanten. Deze talen zijn Verilog en VHDL. In dit artikel zullen we Verilog gebruiken als beschrijvende taal.

Verilog

Onze keuze is gevallen op Verilog omdat deze taal wat duidelijker is dan VHDL. In veel opzichten zijn beide talen echter hetzelfde. Het grootste onderscheid tussen beide talen zit in de manier van beschrijven. Hierdoor zijn veel overwegingen, valkuilen, etc. die in dit artikel aan de orde komen ook direct toepasbaar op VHDL.

Een ontwerp in Verilog kan hiërarchisch van opzet zijn. Dit betekent dat het ontwerp kan worden opgedeeld in kleinere ontwerpen. Deze deelontwerpen op hun beurt kunnen eventueel ook weer worden opgedeeld in diverse deelontwerpen. Zo'n deelontwerp wordt in Verilog aangeduid als 'module'.

Het opsplitsen van een ontwerp in meerdere modules heeft als bijkomend voordeel dat deze modules eventueel ook in een ander ontwerp hergebruikt kunnen worden. Een counter is een voorbeeld van een module die wel vaker gebruikt wordt, dus het plaatsen van een counter in een aparte module is dan wel aan te raden.

Voorbeeld 1

Het beste om iets te leren is om er mee aan de slag te gaan. Vandaar dat we hier al beginnen met een voorbeeld. Allereerst moeten we de voorbeelden downloaden van Internet, vanaf de Elektuur-site (www.elektor.nl). De voorbeelden zijn te vinden onder het nummer 030385-11 bij de juni-artikelen. Het ZIP-bestand hoeft dan alleen nog maar te worden uitgepakt.

In de map Ex1 is voorbeeld 1 te vinden. Dubbelklik simpelweg op het bestand ex1.quartus. De ontwerp-software wordt nu automatisch gestart. In het schema dat nu zichtbaar is, kan men zien dat de diverse I/O-pennen van de chip verbonden worden met een blokje waarin een aantal signalen vermeld zijn. Deze signalen zijn allemaal in- en uitgangen van dit blokje.

Zoals u al in de tutorial heeft gezien (Daar heeft u toch zeker al eens in gekeken?) kunt u door te dubbelklikken op het blokje de bijbehorende broncode openen. In dit geval is dat een broncode, geschreven in de taal Verilog. De tekst die in groen is afgebeeld, is wat Verilog betreft allemaal commentaar en heeft dus geen invloed op het uiteindelijke resultaat. Quartus gebruikt deze regels om informatie in op te slaan. Het is raadzaam om deze regels met commentaar te laten staan.

Opbouw

De opbouw van een broncode in Verilog is altijd volgens dezelfde structuur. Het begint met een declaratie van de module. Dit stuk begint met het woord 'module'gevolgd door een naam. Hierbij hoort een verzameling in- en uitgangen tussen haakjes, met een komma als scheidingsteken. Het geheel wordt afgesloten met een puntkomma. Dit is in ons voorbeeld te vinden op de regels 30 ... 35.

Als volgende moeten we de richting van de signalen (ports) definiëren, die in de module-declaratie vermeld zijn. Zie de regels 39 ... 45 in ons voorbeeld. Er zijn 3 mogelijkheden voor ieder signaal, namelijk input (ingang), output (uitgang) of inout (bidirectioneel signaal). Hier hebben we alleen input en output gebruikt. Iedere regel wordt afgesloten met het karakter ;. In de eerste regel is te zien dat er meerdere signalen gedefinieerd kunnen worden op één regel, mits deze door een komma worden gescheiden.

De uitgangen hebben nog een verdere specificatie nodig. Als de functie van een uitgang in een procedural statement (geen nood, dit wordt later nog uitgelegd) wordt beschreven, dan moet deze van het type reg (register, uitgang van een flipflop) zijn. In regel 47 worden de signalen D2, D3 en D4 gedefinieerd als registers. Nu hebben we alle administratieve plichten vervuld en we kunnen beginnen met ons eigenlijke ontwerp. Dit voorbeeld is, zoals ieder eerste voorbeeld betaamt, zeer eenvoudig. Hierin demonstreren we de mogelijkheid om signalen met booleaanse algebra te beschrijven. Dit kan in Verilog op 2 manieren: met behulp van het statement assign of in een zogenaamd procedural assignment. Een voorbeeld van deze twee methodes toont listing 1. De eerste methode is gedemonstreerd op regel 50. Hier wordt beschreven dat signaal Dl het resultaat is van een AND-bewerking op de signalen Sl ... S4. Dat wil zeggen dat D1 alleen dan actief is als S1 ... S4 ook aktief ('1') zijn. In alle andere gevallen is D1 inactief (V). Het symbool '&' staat dus voor de AND-functie. In tabel 1 zijn alle booleaanse functies in Verilog opgesomd.

Procedural statement

De overgebleven uitgangen (D2 ... D4) worden beschreven in een procedural statement. Deze statements worden altijd vooraf gegaan door het keyword always. Dit keyword wordt in een volgend voorbeeld iets uitgebreider beschreven.

Net zoals in de programmeertaal Pascal kan men verschillende statements samenvoegen tot een geheel door de keywords begin en end. Alle statements daar tussen in worden samen beschouwd als zijnde één statement. Als we nu kijken naar regel 54, dan zien we dat daar signaal D4 wordt beschreven als een signaal dat actief wordt indien S1 of S2 of S3 of S4 actief is. Met opzet is hier het woord 'wordt' gebruikt in plaats van 'is'. Het teken <= betekent 'wordt'. Als vuistregel geldt dat in een procedural statement gebruik wordt gemaakt van dit teken in plaats van het = teken.
De functies van de signalen D3 en D4 zijn ook niet moeilijk te doorgronden, indien men even spiekt in tabel 1.

Het nut om signalen in een procedural statement te plaatsen i.p.v. te werken met een assign, zal in een volgend voorbeeld duidelijk worden. Tenslotte wordt d.m.v. het keyword endmodule aangegeven dat we nu klaar zijn met de beschrijving van de module.

Tabel 1. Booleconse funkties

&AND
~&NAND
|OR
~|NOR
~NOT
^XOR
~^XNOR

Tabel 2. Rekenkundige operotoren

+optellen
-aftrekken
*vermenigvuldigen
/delen
%modulo

Tabel 3. Relationale operotoren

>groter dan
>=groter dan of gelijk aan
<kleiner dan
<=kleiner dan of gelijk aan
==gelijk aan
!=niet gelijk aan

Listing 1. Booleaanse algebra
50 assign D1 = S1 & S2 & S3 & S4;
51
52 always
53  begin
54   D2 <= S1 | S2 | S3 | S4;
55   D3 <= (S1 & S2) | (S3 & S4);
56   D4 <= -(Sl & S2 & S3 & S4);
57  end

Compilieren

Dan wordt het nu tijd om langzamerhand eens de handen uit de mouwen te steken. Allereerst moeten we het ontwerp compileren. De compiler weet al precies welk signaal met welke pen van de CPLD verbonden moet worden. Dit hebben wij al voor u gedaan. Compileren wordt daardoor een kinderspel, u hoeft alleen maar in het menu Processing op Start Compilation te klikken en de software gaat aan de slag.

Nu verschijnen er wat meldingen op het scherm en zullen verschillende balkjes bewegen. Na een tijdje zal de software melden dat het compileren geslaagd is. Dit betekent dat de software een programmeerbestand heeft aangemaakt waarmee we onze chip kunnen programmeren.

Programmeren

Bij het programmeren heeft u zoals in het vorige artikel vermeld is, de JTAG-programmer uit de Halfgeleidergids van 2002 nodig. Een originele ByteB-laster van Altera is natuurlijk ook goed. We gaan er van uit dat de programmer met de printerpoort van de PC is verbonden en de JTAG-connector is verbonden met connector K2 van onze experimenteerprint. Schakel nu de experimenteerprint in.

In Quartus selecteren we het menu tools en vervolgens programmer. Een nieuw venster verschijnt. Controleer of de programmer op JTAG is ingesteld en de interface (ByteBlaster) is geselecteerd.

In het venster staat nu een regel met daarin onder de kolom Device een EPM7128SLC. Op dezelfde regel zal onder de kolom File het programmeerbestand ex1.pof vermeld staan. Alles is nu gereed om de CPLD te programmeren. Nu moeten we de software aangeven dat we deze chip willen programmeren door een vinkje te plaatsen onder de kolom Program/Configure.

Als laatste klikken we op de knop Start Programming die te herkennen is aan een soort PLAY-knop, helemaal bovenaan.

Testen

Na het programmeren wordt de CPLD meteen actief, d.w.z. het geprogrammeerde ontwerp is direct functioneel. Zorg ervoor dat de jumpers JP1 en JP2 zijn ingeschakeld.

Het controleren van het ontwerp is nu eenvoudig. LED D1 mag alleen dan 'aan' zijn indien alle schakelaars in de stand '1' staan. In alle andere gevallen moet de LED doven. LED D4 daarentegen moet precies het tegenovergestelde doen. Dus als Dl oplicht, moet D4 gedoofd zijn en vice versa.

D2 is door ons beschreven als een OR-functie, d.w.z. zodra een of meerdere schakelaars in de stand '1' staan, moet deze LED oplichten. Led D3 moet oplichten zodra S1 en S2 in de stand '1' staan OF S3 en S4 in de stand '1' staan. Deze functies zijn allemaal gemakkelijk te controleren met behulp van de schakelaars.

Probeer zelf eens het ontwerp zo aan te passen in Quartus, dat LED D1 oplicht zodra S1 in de stand '1' staat en S2 in de stand V staat. De stand van de andere schakelaars doet er niet toe. Veelsucces!

Voobeeld 2

Voorbeeld 1 was zoals gezegd een zeer eenvoudig voorbeeld. De kracht van Verilog is juist dat de ontwerper een meer beschrijvende manier heeft van ontwerpen. Booleaanse algebra kan wel eens handig zijn in Verilog, maar het is zeker niet de bedoeling dat de complexere ontwerpen helemaal in booleaanse algebra ingevoerd moeten worden.

Hoe dit eruit kan zien, demonsteren we aan de hand van voorbeeld 2, waarin we 2 flipflops en een latch gaan ontwerpen. De-bestanden van voorbeeld 2 zijn te vinden in de map ex2. Hiervan openen we ex2.quartus, waarna de software automatisch alle overige benodigde bestanden opent.

In het schema (ex2.bdf zien we dat de schakelaars S1 ... S4 verbonden zijn met een functioneel blok, flipflop genaamd. S1 is verbonden met de CLK-ingang, etc. Door middel van een dubbelklik op dit blok opent u de bijbehorende Verilog-broncode.

Afways @

Tot aan regel 46 zien we niks nieuws. In regel 46 daarentegen staat een toevoeging bij het keyword always, namelijk een @ gevolgd door een vergelijking. Dit stukje code is ook te zien in listing 2. Het @-teken geeft aan dat de procedural-statements behorende bij dit always-statement alleen dan mogen worden geëvalueerd als voldaan is aan de navolgende vergelijking (niet uitvoeren, dat doen alleen processoren!). In dit geval betekent dit dat de onderstaande statements alleen maar van toepassing zijn op het moment dat het kloksignaal (CLK) OF het reset-signaal OF het set-signaal een opgaande flank (posedge) heeft. Ter verduidelijking: Een opgaande flank is de overgang van een logische nul naar een logische één.

Verilog kent ook de toevoeging 'negedge', wat in het Nederlands zoveel betekent als 'negatieve flank' oftewel neergaande flank.

Indien één van deze voorwaardes geldt, dan wordt het stukje code geëvalueerd. Allereerst wordt er gekeken of het reset-signaal '1' is. Is dat het geval, dan wordt OUT inactief ('0') en is dit stukje code klaar. In het andere geval wordt er gekeken of dan misschien het signaal SET '1' is. Zoj a, dan wordt uitgang OUT 1' en is de code klaar.

Naast de waarden '1' en '0' kan ieder signaal ook nog de waardes 'x' (onbekend) of 'z' (hoge impedantie) aannemen.

Als zowel RESET als SET niet '1' is, dan moet CLK wel een opgaande flank hebben, anders zou deze code niet geëvalueerd worden. De bedoeling is dat de de uitgang van de flipflop bij een opgaande flank van het kloksignaal de waarde van de ingang overneemt.

Wat gebeurt er nu met de uitgang op het moment dat er geen opgaande flank aan CLK, RESET of SET is? Welnu, het antwoord is zeer eenvoudig: niks. In regel 45 is het signaal OUT gedefinieerd als een register, wat inhoudt dat de laatste waarde die aan dit signaal is toegekend moet worden onthouden. Op het moment dat er geen code actief is, zal de waarde van dit register ook niet veranderen. Door de toevoeging van het '@'-teken bij het statement 'always' kunnen we dus aangeven onder welke voorwaarden een stukje code geëvalueerd mag worden. De rest van de tijd moet de uitgang die in dit blok bestuurd wordt, hetzelfde blijven.

Aan de hand van de code is duidelijk te zien dat de RESET-ingang een hogere prioriteit heeft dan de SET-ingang. Dit betekent echter niet dat de CPLD tijdens bedrijf deze 2 signalen achter elkaar evalueert. De CPLD zal net zo snel reageren op het RESET-signaal als op het SET-signaal. De volgorde is alleen belangrijk voor de compiler. Deze evalueert een stukje code en bepaald wat er met de uitgang moet gebeuren bij iedere denkbare combinatie van ingangssignalen. Aan de hand van deze evaluatie 'ontwerpt' de compiler een stukje digitale logica dat precies zo reageert als in de code is beschreven.

Variatie op het thema

In het schema (ex2.bdf) is nog een tweede flipflop getekend, met de toepasselijke naam 'flipflop 2', Het bijbehorende Verilog-bestand lijkt zeer veel op het Verilog-bestand van de eerste flipflop. Het enige verschil met de vorige flipflop zit in het feit dat eerst naar de toestand van het SET-signaal gekeken wordt en pas daarna naar het RESET-signaal. Dit betekent dat bij deze flipflop de SET-ingang een hogere prioriteit heeft dan de RESET-ingang. De uitgang zal dan ook '1' worden indien zowel de RESET- als de SET-ingang '1' is. Bij de vorige flipflop zal in die situatie de uitgang '0' worden.

Latch

Als laatste blokje in dit schema is een latch getekend. Ook een latch is een vaak gebruikte bouwsteen in digitale ontwerpen. De functie van een latch is eigenlijk zeer eenvoudig: Zolang de klokingang '1' is, moet de uitgang hetzelfde zijn als de ingang. Zodra de toestand aan de ingang verandert, moet de uitgang deze verandering ook volgen. Is het kloksignaal daarentegen inactief ('0'), dan moet de laatst bekende toestand aan de uitgang behouden blijven, ongeacht veranderingen aan de ingang. In het Verilog-bestand latchexample.v is te zien hoe zoiets in Verilog beschreven kan worden. Het uitgangssignaal kan veranderen indien de toestand van het kloksignaal verandert OF de toestand van de data-ingang veranderd. Dit kan zowel op de opgaande flank als op de neergaande flank zijn. Achter het @-teken zien we dan ook '(posedge CLK or D)', Wat opvalt, is dat het signaal D genoemd wordt, zonder 'posedge' ervoor. Dit betekent dat de code geëvalueerd moet worden bij iedere verandering van signaal D.

In de code behorend bij dit always-statement zien we dat er door de compiler eerst gekeken wordt naar de toestand van het klok-signaal. Is dit actief (T), dan wordt de uitgang gelijk aan de ingang. Zoniet, dan gebeurt er niets en blijft de huidige toestand van de uitgang hetzelfde.

Dit voorbeeld kunnen we nu op precies dezelfde manier als het voorgaande voorbeeld compileren en programmeren. Verifieer daarna m.b.v. het experimenteerbord of dit ontwerp daadwerkelijk doet wat we ervan verwachten. Als oefening kunt u daarna eens proberen of u de latch ook kunt voorzien van een SET- en een RESET-ingang. Oefening baart kunst, volgens het gezegde!


Figuur 1. Schema van een standaard kristaloscillator.

Rekenen

In het vorige voorbeeld is gedemonstreerd hoe we een functie kunnen omschrijven zonder ons bezig te houden met logische poortjes, booleaanse algebra, etc. Na enig stoeien met Verilog zal iedere ontwerper dit wel kunnen waarderen. De meer triviale zaken worden nu door de compiler afgehandeld, i.p.v. door de ontwerper. In voorbeeld nr. 3 laten we zien dat ook rekenen geen probleem is in Verilog. We maken in dit voorbeeld gebruik van tellers. Deze tellers hebben een kloksignaal nodig en daar gaan we dan mee beginnen.

In figuur 1 is een standaard kristaloscillator getekend. Op de inverter na zijn alle onderdelen op de experimenteerprint aanwezig. Door nu tussen de pennen 71 en 81 van de CPLD een inverter te plaatsen, hebben we een kristaloscillator.

Als we voorbeeld 3 openen, dan zien we boven in het schema deze inverter tussen 2 aansluitingen van het IC getekend. Na het programmeren van de CPLD ontstaat dus een oscillator waarvan de uitgang (pen 81 op de printplaat) verbonden is met pen 83 van de CPLD. Deze ingang is speciaal bedoeld om als klokingang te fungeren.

Listing 2. Een geklokte flipflop
46 always @ (posedge CLK or posedge RESET or posedge SET)
47 begin
48   if (RESET)
49     OUT <= 1'b0;
50   else if (SET)
51     OUT <= 1'b1;
52   else
53     OUT <= D;
54 end

Arrays

We gaan ervan uit dat u bekend bent met het rekenen in het binaire stelsel. Dan zult U vast wel weten dat getallen meestal door een groep van signalen worden weergegeven. In Verilog kan men een aantal signalen makkelijk groeperen in zogenaamde arrays. In het Verilog-bestand van het blokje Count zien we dan ook op regel 40 staan: 'output [7:0] D;'. Dit specificeert een array van 8 signalen, namelijk D[7] ... D[0]. Alle signalen samen kunnen we schrijven als 'D'. We moeten voor alle duidelijkheid regel 47 verklaren. Hierin is een nieuw signaal gedeclareerd. Dit signaal komt niet voor in de module-declaratie en dat wil dus zeggen dat dit signaal niet naar buiten toe (de module) zichtbaar is. Zo'n signaal is puur voor intern gebruik.

De volgende interessante regel is regel 51: 'temp = temp + 1;'. We kunnen dus tellen door gewoon het '+'-teken te gebruiken. In tabel 2 staan nog meer (rekenkundige) operatoren die in Verilog gebruikt kunnen worden bij arrays.

In regel 52 zien we een vergelijking ('==' betekent controleren of het linker lid gelijk is aan het rechter lid). In tabel 3 staan alle relationele operatoren in Verilog (zoals '==') vermeld. Het getal 24'd4000000 ziet er op eerste gezicht misschien vreemd uit. Dit is de schrijfwijze voor getallen in Verilog. Het eerste getal geeft aan om hoeveel signalen het gaat (24 in dit geval). De 'd' geeft aan dat de constante in decimale schrijfwijze wordt gegeven. 4000000 is tenslotte de feitelijke constante.

We moeten in dit geval 24 signalen gebruiken, aangezien het register temp bestaat uit 24 signalen. 24 nullen is in Verilog niet gelijk aan 23 nullen! Let er dus goed op dat zowel links als rechts van het '= ='-teken even veel signalen staan!

Teller

Als we de Verilog-code analyseren, dan zien we dat bij iedere klokpuls de waarde van register temp wordt verhoogd. Zodra dit register de waarde 4.000.000 krijgt, wordt register D met de waarde'l'verhoogd, temp wordt'O' en uitgang SLOW wordt 'l'. Heeft register temp de waarde 4.000.000 nog niet bereikt, dan krijgt SLOW de waarde'O'.

Bij een kloksignaal van 4,000 MHz betekent dit dat 1 keer per seconde de waarde van register D verhoogd wordt en dat uitgang SLOW korte tijd 'l' wordt. SLOW is dus een kloksignaal van 1 Hz.

Listing 3. Het statement "case" en signalen samenvoegen tot een array
59 always @ (COUNT)
60   begin
61   case (COUNT)
62     4'd0 : SEG=7'b111111O;
63     4'd1 : SEG=7'b0110000;
..................................................... . . .
71     4'd9 : SEG=7'b1111O11;
72     default : SEG=7'b0000001;
73   endcase
74 end
75
76 always @(SEG)
77   {SEGA,SEGB,SEGC,SEGD,SEGE,SEGF,SEGG} = SEG;

BCD-teller

Het kloksignaal van 1 Hz gaat naar de klokingang van een BCD-teller. Deze is in het schema aangeduid als 'BCD counter'. De Verilog-code voor de BCD-teller bevat maar liefst drie aparte blokjes die beginnen met het statement 'always'. Verder moeten we er nog op wijzen dat er nog 2 registers voor intern gebruik zijn gedeclareerd, namelijk SEG en COUNT. De eerste functie (vanaf regel 52) is een teller die er voor zorgt dat register COUNT van 0 tot 9 telt. Bij het bereiken van de waarde 10 wordt COUNT weer geladen met de waarde 0. De tweede functie wordt iedere keer doorlopen als COUNT verandert. In regel 60 vinden we een nieuw statement met de naam case. Een voorbeeld hiervan is te vinden in listing 3. C-programmeurs zal dit bekend in de oren klinken. Het case-statement heeft 1 argument (COUNT) in dit geval. De volgende regels zijn dan als volgt te vertalen:
4'd0: SEG=7'b1111110;
4'd1: SEG=7'b0110000;
kan worden vertaald als:
if(COUNT == 4'd0) SEG=7'b...
else if (COUNT == 4'd0) SEG=...
enzovoorts

De regel beginnend met default wordt uitgevoerd indien de huidige waarde van COUNT niet in de lijst voorkomt. Het laatste stukje Verilog-code vinden we op regel 75. Zoals te zien is, wordt dit geëvalueerd indien register SEG van waarde verandert. Op regel 76 zien we een interesante mogelijkheid van Verilog. Met behulp van de tekens '{' en '}' kunnen we meerdere signalen samenvoegen tot een array. Aangezien SEG een array is en de uitgangen voor de 7-segments displays als 'losse' signalen gedeclareerd zijn, moeten we deze signalen kunen koppelen aan een array. Een andere oplossing zou kunnen zijn dat we ieder signaal koppelen aan een onderdeel uit het array, bijvoorbeeld:
SEGA = SEG[6];
Deze methode werkt net zo goed, maar dat zou de code een stukje langer en dus ondoorzichtiger maken.

Testen

Bij het testen van dit voorbeeld moeten we een onvolmaaktheid van de experimenteerprint bespreken.

Tijdens het programmeren van de CPLD gaan alle uitgangen op nonactief. Meteen na het programmeren is de CPLD actief. Hierdoor start de oscillator niet goed op. Na het programmeren moet u dus nog even een reset geven. Dit kunt U doen door een drukknop met maakcontact te plaatsen tussen de pennen 2 en 20 op konnektor K6. Als alternatief kunt u ook de voedingsspanning even uit- en en weer inschakelen.

Tot slot

De taal Verilog kent nog veel meer mogelijkheden dan we hier in dit artikel kunnen beschrijven. We hebben ons beperkt tot de meest gebruikte mogelijkheden van Verilog. Deze stellen de gebruiker in staat om toch zeer complexe digitale functies te ontwerpen. Op Internet zijn diverse sites te vinden met de meest uiteenlopende ontwerpen in Verilog. Door deze ontwerpen te bestuderen en te simuleren kunt u op een snelle manier veel ervaring opdoen in deze interessante taal.

Een belangrijk punt dat we in dit artikel niet behandelen vanwege plaatsgebrek, is het simuleren van een ontwerp in Quartus. De tutorial van Quartus kan u daarbij een flink stuk op weg helpen en verder is er altijd nog de helpfunctie.

Het is trouwens raadzaam om een ontwerp in kleine delen te ontwerpen en deze kleinere deelontwerpen één voor één te simuleren, om na te gaan of ze volgens plan werken.

Wij horen het graag als u zelf een interessante applicatie gemaakt heeft met onze experimenteerprint! Veel succes!

Tips

Interessante links:

http://www.asic-world.com/verilog/index.html