IDLab - Vakgroep Elektronica en Informatiesystemen (ELIS) Practicumnota s Digitale Elektronica prof. dr. ir. J. Dambre Academiejaar 2016 2017
Inhoudsopgave 1 Aan de slag met Vivado en Basys3 1 1.1 Doelstellingen................................... 1 1.2 Voorbereiding................................... 1 1.3 Opgave...................................... 1 1.4 Rapportering................................... 2 I Een eenvoudige rekenmachine 3 2 Aansturing van de LED-cijferdisplays 4 2.1 Doelstellingen................................... 4 2.2 Voorbereiding................................... 4 2.3 Aansturing van de Basys3 LED-displays.................... 4 2.4 opgave...................................... 5 2.4.1 Eerste beschrijving............................ 5 2.4.2 Automatische verificatie aan de hand van een testbank....... 6 2.4.3 Tweede beschrijving........................... 6 2.4.4 Analyse van de vertragingen...................... 6 2.5 Rapportering................................... 6 3 Combinatorische modules in het datapad 7 3.1 Doelstellingen................................... 7 3.2 Voorbereiding................................... 7 3.3 Opgave...................................... 7 3.3.1 Multiplexers en demultiplexers..................... 7 3.3.2 Optellen.................................. 8 3.3.3 Optellen en aftrekken.......................... 9 3.3.4 Omzetten van bitvectoren naar BCD-getallen............. 10 3.4 Rapportering................................... 10 4 Sequentiële modules in het datapad 11 4.1 Doelstellingen................................... 11 4.2 Voorbereiding................................... 11 4.3 Opgave...................................... 11 4.3.1 De klok.................................. 11 4.3.2 De display driver............................. 12 4.3.3 Registers................................. 12 4.3.4 Componenten met variabele woordbreedte: generic parameters.. 12 4.3.5 Een synchrone BCD op- en neerteller................. 13 i
4.3.6 De knopjes................................ 14 4.3.7 Test voor het invoeren van data..................... 15 4.4 Rapportering................................... 15 5 Het datapad en de controller 16 5.1 Doelstellingen................................... 16 5.2 Voorbereiding................................... 16 5.3 Opgave...................................... 16 5.3.1 Het gedrag van de rekenmachine.................... 16 5.3.2 Datapad en controller.......................... 17 5.3.3 Verificatie met ROM-bestanden..................... 18 5.3.4 Testen in hardware............................ 19 5.4 Rapportering................................... 19 ii
Hoofdstuk 1 Aan de slag met Vivado en Basys3 1.1 Doelstellingen In dit practicum is het de bedoeling vertrouwd te worden met het Basys3 FPGA-bordje van Digilent, dat we voor de rest van de practica zullen gebruiken, met de Xilinx-Vivado software en met de stappen die moeten doorlopen worden om een ontwerp in FPGA te realiseren. 1.2 Voorbereiding Dit practicum behoeft niet meer voorbereiding dan het vooraf lezen en het meebrengen van de practicumopgave en het doornemen van het lesmateriaal over FPGAs en de inleidende slides i.v.m. VHDL. 1.3 Opgave Open de technische beschrijving van het Basys3-bordje en bekijk welke verschillende onderdelen dit bevat. Ga in het bijzonder na welke manieren er beschikbaar zijn om ingangssignalen naar de FPGA te voeren en wat je kan aansturen met de uitgangssignalen van de FPGA. Om digitale ontwerpen te maken en deze te implementeren in het Basys3 bordje zullen we de Xilinx Vivado software-omgeving gebruiken. Deze is geïnstalleerd in PCklassen A en B en op Athena (in de map academic electronics). Met de versie op Athena kan je alles doen behalve een ontwerp effectief op het bordje implementeren, dus wel VHDL code schrijven, simuleren, synthetiseren en simulaties met tijdsinformatie uitvoeren (de extractiestap uit het Gajski-diagram). Je kan ook de gratis versie van Vivado (de zogenaamde HL WebPack Edition) op je eigen computer (enkel Windows of Linux) via de link https://www.xilinx.com/products/design-tools/vivado/vivado-webpack.html Open Xilinx Vivado en volg de instructies in de Vivado tutorial (Vivado Tutorial.pdf). Tracht zo goed mogelijk te begrijpen wat er in de verschillende stappen gebeurt. In het bijzonder moet je aan het eind van dit gedeelte weten: hoe je een nieuw project start om een ontwerp te maken dat moet worden gerealiseerd in het Basys3-FPGA bordje 1
welke in- en uitgangen voor de FPGA op het bordje aanwezig zijn en hoe je in- en uitgangen van je ontwerp kan verbinden met de schakelaars, drukknopjes, LEDs en cijferdisplays van het bordje hoe je nieuwe VHDL-bestanden en testbanken aan je ontwerp toevoegt hoe je je ontwerp kan simuleren met behulp van een testbank hoe je je ontwerp kan verificeren met behulp van een testbank hoe je via de golfvormen alle signalen in alle modules van je ontwerp kan bestuderen om na te gaan waardoor eventuele fouten veroorzaakt worden hoe je ervoor zorgt dat bepaalde bestanden wel of niet mee gesimuleerd worden hoe je ervoor zorgt dat bepaalde bestanden wel of niet mee gesynthetiseerd worden hoe je je ontwerp synthetiseert (logische synthese) en afbeeldt op de hardware (fysische synthese) hoe je na fysische synthese een simulatie kan doen met vertragingsinformatie (backannotation - timing simulation) met dezelfde testbank die je gebruikte om je VHDL-code te verificeren hoe je kan nagaan hoeveel plaats je ontwerp inneemt op de FPGA hoe je de programmeer-informatie voor je FPGA kan genereren en de FPGA kan programmeren om te testen of je ontwerp correct werkt 1.4 Rapportering Voor dit onderdeel is geen rapportering vereist. 2
Deel I Een eenvoudige rekenmachine 3
Hoofdstuk 2 Aansturing van de LED-cijferdisplays 2.1 Doelstellingen In dit practicum wordt aan de hand van het aansturen van de LED-cijferdisplays het beschrijven van combinatorische schakelingen in VHDL aangeleerd. Het beschreven gedrag wordt geverificeerd aan de hand van een testbank en getest op de hardware. 2.2 Voorbereiding Ter voorbereiding van dit practicum dien je de practicumopgave door te nemen en de slides i.v.m. het realiseren van combinatorisch gedrag in VHDL. Indien je de lessen hebt bijgewoond zou je vertrouwd moeten zijn met alle begrippen die in de opgave voorkomen (i.h.b. de termen waarheidstabel en Boolese vorm). Mocht dit niet het geval zijn, dan wordt je geacht het betreffende lesmateriaal door te nemen vooraleer je naar het practicum komt. 2.3 Aansturing van de Basys3 LED-displays Een BCD-getal (binary coded decimal) is een 4-bitgetal dat een decimaal cijfer (0-9) voorstelt. De codering is hierbij niet anders dan bij een gewoon 4-bitgetal, behalve dat we op voorhand afspreken dat de codes die overeenstemmen met de getallen 10-15 niet gebruikt worden. In dit practicum maak je verschillende versies van een VHDL-module die een BCD-getal omzet naar de aanstuursignalen voor een LED-cijferdisplay. Figuur 2.1 toont hoe de LEDs (LED = light emitting diode) op het bordje geschakeld zijn. Om een segment aan te schakelen moet er stroom door de LED vloeien. Daarvoor moet de anode die LED dus hoog zijn en de kathode laag. Voor elk van de 4 LED-displays is er één gemeenschappelijke anode. Voor elke set van 4 overeenstemmende segmenten (bijvoorbeeld segment 0 in de rechtse afbeelding van figuur 2.1) is er één gemeenschappelijke kathode. Om dus bijvoorbeeld enkel de meest rechtse display het cijfer 1 te laten weergeven moet anode(0) hoog zijn (de andere anodes laag) en moeten kathode(1) en kathode(2) laag zijn (de andere kathodes hoog). In het configuratiebestand waarin de in- en uitgangen worden geactiveerd zijn de anodes aangeduid met de naam an en de kathodes met de naam seg. 4
Figuur 2.1: Aansturing van de segmenten van de LED-display. Als meerdere anodes tegelijk hoog zijn, zullen alle overeenkomstige displays hetzelfde patroon vertonen. Om de displays een verschillend patroon te laten weergeven worden ze één voor één aangestuurd met zo n hoge frequentie dat het menselijk oog geen flikkering waarneemt. 2.4 opgave 2.4.1 Eerste beschrijving Start nu een nieuw project. Let erop dat je dit doet op een pad waarvan de naam geen spaties bevat. Gebruik dezelfde instellingen als in de vorige opgave en importeer opnieuw het Basys3 configuratiebestand Basys3 Master.xdc. Voeg de VHDL-bestanden bcdto7segment boolsevormen.vhd en single display driver.vhd toe. Het laatste bestand is het topniveau van dit project. Het stuurt de anodes zó aan dat enkel de eerste display actief is en verbindt de decoder, beschreven in het tweede bestand, tussen de meest rechtse 4 switches en de 7 kathodes. Activeer de nodige inputs en outputs in het configuratiebestand. In de architecture van de decoder wordt nu aan alle kathodes de waarde 0 toegekend (LED niet actief). Beschrijf nu in VHDL het gedrag dat het bitpatroon van de switches omzet naar het overeenkomstige patroon op een LED-display. Doe dit door voor elke kathode een boolese vergelijking neer te schrijven en deze letterlijk te vertalen naar VHDL. Daarvoor kan je and, or en not() gebruiken. Voeg het testbankbestand ingangspatronen.vhd toe aan je simulatiebestanden (add simulation inputs) en bestudeer de code ervan. Dit bestand overloopt 1 maal alle ingangspatronen. Je kan het later gebruiken als basis voor het simuleren van andere combinatorische circuits. Ga na dat het testbankbestand enkel wordt vermeld bij de simulation sources, niet bij de design sources. Simuleer de testbank en bestudeer de golfvormen. Tracht aan de hand van de golfvormen na te gaan of jullie implementatie correct is. Als je wijzigingen aan je bestanden moet aanbrengen, kan je de simulatie op twee manieren herstarten: via het commando restart (terugspoel-icoontje) of via het commando relaunch (icoontje met terugdraaiende pijl). Let op: enkel in het laatste geval worden gewijzigde VHDL-bestanden automatisch opgeslagen en opnieuw gecompileerd. Gebruik dus best altijd relaunch! Let ook op: als je nieuwe interne signalen of variabelen toevoegt in je VHDL-bestand, worden die meestal zelfs niet zichtbaar via relaunch. In dat geval moet je de simulatie sluiten en een nieuwe simulatie starten. 5
2.4.2 Automatische verificatie aan de hand van een testbank Maak voortaan voor elke deelmodule (entity) die je beschrijft een testbankbestand dat minstens de simulatie automatiseert en bij voorkeur ook automatisch het gedrag controleert. Het testbankbestand ingangspatronen en controle.vhd bevat zo n automatisch controleproces. Importeer het en kies de overeenkomstige entity als topniveau in de simulation settings. Simuleer de nieuwe testbank en ga na of alles correct verloopt. Breng enkele foutjes aan in je model en controleer of de testbank deze detecteert. Deze testbank overloopt enkel de geldige BCD-patronen 0000 t.e.m. 1001. Pas de testbank nu aan zodat hij alle 4-bit patronen overloopt. Hiervoor moet je op twee plaatsen in de VHDL code wijzigingen aanbrengen. Vraag: Wat doet jullie ontwerp voor de bitpatronen die overeenstemmen met ingangswaarden 10-15? Komt dit overeen met je verwachtingen? Synthetiseer en implementeer het project en programmeer het Basys3 bordje en test het gedrag door de schakelaars te verzetten. 2.4.3 Tweede beschrijving Voeg nu het VHDL-bestand bcdto7segment waarheidstabel.vhd toe aan je ontwerp. Hierin wordt een tweede architecture voor de entity bcdto7segment aangemaakt. Vul het bestand aan met een architecture-beschrijving die letterlijk de waarheidstabel van de gewenste decoder implementeert. Een letterlijke vertaling van de waarheidstabel verkrijg je door gebruik te maken van een case-statement. Hou er rekening mee dat de 4-bit ingang een BCD-getal voorstelt en het gedrag van de schakeling voor ingangswaarden 10-15 dus niet van belang is. Merk op dat een signaalwaarde X door Vivado behandeld wordt als een don t care uitgang. Verificeer ook jullie tweede versie aan de hand van simulatie. Pas hiervoor eerst de gebruikte architecture van de decoder aan in het bestand single display driver.vhd. Pas tenslotte je laatste ontwerp aan zodat het ingangspatroon 1111 een min-teken (enkel segment 6) realiseert en voer nog éénmaal de verificatie- en teststappen uit. 2.4.4 Analyse van de vertragingen Doe nu ook een tijdssimulatie (post-implementation en meet op de golfvormen de vertragingstijden tussen een overgang aan de ingangen en het tijdstip waarop alle displayuitgangen hun stabiele eindwaarde bereikt hebben en neem de gerapporteerde vertragingen op in je verslag. Vraag: Zijn de vertragingen voor éénzelfde uitgang steeds gelijk? Kan je dit verklaren? Vraag: Zijn de overgangen steeds monotoon? Welk fenomeen nemen we hier waar? 2.5 Rapportering De rapportering voor dit onderdeel gebeurt na het afronden van Hoofdstuk 3. Dien je VHDL-bestanden in samen met een kort verslag dat screenshots bevat van correcte simulatiegolfvormen (zonder- en met tijdsinformatie) en de antwoorden op de vragen die gesteld worden in de tekst. 6
Hoofdstuk 3 Combinatorische modules in het datapad 3.1 Doelstellingen In dit onderdeel implementeer je de combinatorische onderdelen van het datapad van je rekenmachine. 3.2 Voorbereiding Ter voorbereiding van dit practicum dien je de opgaven van Hoofdstukken 1 en 2 te hebben afgewerkt en de opgave van dit hoofdstuk door te nemen. Opnieuw wordt verondersteld dat je vertrouwd bent met alle begrippen die in de opgave worden gebruikt. 3.3 Opgave Maak een nieuw project voor dit practicum en importeer het blanco configuratiebestand. Activeer waar nodig voor elke deelopgave de gebruikte ingangen en uitgangen. Voeg telkens je nieuwe VHDL-bestanden toe maar zorg ervoor dat voor elke opgave enkel de voor die opgave relevante entities en/of testbanken actief staan. Let erop dat je afgewerkte bestanden niet verwijdert want je moet ze later nog hergebruiken en ook indienen (je kan ze inactief maken door de optie disable te gebruiken). 3.3.1 Multiplexers en demultiplexers Een multiplexer wordt gebruikt om één uit meerdere ingangen (bits of bitvectoren) te selecteren en door te koppelen naar een uitgang. Voor N verschillende ingangen worden log 2 (N) selectiebits gebruikt. Een demultiplexer werkt net omgekeerd: één enkele ingang wordt doorgekoppeld naar één uit N uitgangen. Beschrijf een multiplexer die selecteert tussen 2 4-bitsignalen (een 2-naar-1 multiplexer met woordbreedte 4) en simuleer het gedrag met een eenvoudige testbank. Zorg ervoor dat de testbanksignalen zó worden aangelegd dat er steeds maar 1 ingang tegelijk verandert en controleer op de golfvormen of de uitgang ook steeds mee-verandert. Doe hetzelfde voor een 1-naar-2 demultiplexer met woordbreedte 4. 7
Figuur 3.1: Blokschema van een ripple-carry opteller. Figuur 3.2: Blokschema van een carry-lookahead opteller. 3.3.2 Optellen In een ripple-carry opteller worden meerdere 1-bitoptellers ( (full adders) gecombineerd tot een meerbitopteller volgens het schema van figuur 3.1. Een full-adder heeft twee op te tellen ingangsbits en een carry-ingang, een som-uitgang en een carry-uitgang. Schrijf de Boolese vormen neer voor beide uitgangen van de full-adder en schrijf een VHDL entity full adder die deze realiseert. Maak dan in een tweede entity adder4 een 4-bit opteller door 4 full-adderblokjes te combineren zoals aangegeven in het schema. Noem de architecture rca. De ingangen zijn 2 maal 4 bit voor de operandi en 1 bit voor de carry-in. De uitgangen zijn het 4-bit resultaat en de carry-out. Maak nu een top-niveau entity waarin de opteller tussen de eerste 8 schakelaars (2 4-bitgetallen) en de eerste 5 ledjes (carry-uitgang en 4-bitgetal) wordt geschakeld. Verbind de carry-ingang met de 9-de schakelaar (sw8). Verificeer je opteller aan de hand van een automatische testbank die met één enkele 9-bit teller alle mogelijke ingangspatronen overloopt. Implementeer en doe een tijdssimulatie. Vraag: Voor welke ingangstransitie(s) is de vertraging het grootst? Leg uit. Een alternatieve implementatie van een meerbitopteller is gebaseerd op het principe van carry-lookahead. In dit schema worden voor elke 1-bitoptelling twee signalen berekend: G (voor generate) en P (voor propagate). Het eerste signaal geeft aan of het carry-out signaal zowieso hoog moet zijn (onafhankelijk van carry-in) en wordt bepaald door de Boolese vorm G i = A i B i. Het tweede geeft aan of de carry-ingang gewoon moet worden doorgegeven van ingang naar uitgang: P i = A i + B i. Aangezien beide signalen 8
enkel afhangen van de operandi, kunnen ze voor alle ingangsbits in parallel berekend worden. De uitdrukking voor de carry-uitgangen wordt hierdoor eenvoudiger, namelijk: C i+1 = G i + P i C i. Het resulterende optellerschema wordt weergegeven in figuur 3.2). Beschrijf nu in VHDL één CLA-blok en gebruik 4 cla-blokken om een tweede architecture, genaamd cla, te maken voor de entity adder4. verificeer met dezelfde testbank, implementeer, test en rapporteer de maximale combinatorische vertraging. 3.3.3 Optellen en aftrekken We maken nu een combinatorische module die zowel de som als het verschil van twee 4-bitgetallen kan berekenen. We zullen er hierbij geen rekening mee houden dat deze getallen BCD-getallen voorstellen. De uitgangen van de module stellen de absolute waarde voor van het resultaat (5 bit) en een tekenbit. Een veel gebruikte methode om twee positieve binair gecodeerde getallen van elkaar af trekken is de complementmethode. Deze bestaat erin om het twee-complement te nemen van het af te trekken getal en dit bij het eerste getal op te tellen. Het twee-complementgetal krijgt men door alle bits te inverteren en 1 op te tellen bij het resultaat. Om geen twee optellingen te moeten uitvoeren, gebruikt men hiervoor één opteller waarvoor het tweede argument het bitgewijze complement is van het af te trekken getal en waarbij de carry-ingang van de eerste trap op 1 wordt gezet. Het resultaat staat eveneens in twee-complementnotatie. Bij het optellen stellen de carry-uitgang en de 4 som-bits samen de absolute waarden van het resultaat voor. Bij het aftrekken vergt het iets meer werk om het resultaat te interpreteren. Is de carryuitgang hoog, dan is het resultaat positief en stellen de 4 som-bits de absolute waarde van het resultaat voor. Is de carry-uitgang laag, dan is het resultaat negatief en moet men opnieuw het twee-complement nemen van de 4 som-bits om de absolute waarde van het resultaat te vinden. Aangezien dit een extra optellervertraging met zich meebrengt, is het efficienter om bij aftrekking A - B en B- A in parallel te berekenen en, afhankelijk van het resultaat, de juiste bits te selecteren om de absolute waarde van het verschil te bepalen. Bij het optellen geven beide optellerblokken natuurlijk hetzelfde resultaat. Ga zelf na wat het resultaat is als je twee identieke getallen van elkaar aftrekt. Vraag: Leg uit waarom je bij het optellen 5 bits gebruikt voor de absolute waarde en bij het aftrekken maar 4. Teken een blokschema van de architectuur die bovenstaande beschrijving realiseert. Deze heeft twee 4-bit ingangen, een opcode-ingang die laag is voor optellen en hoog voor aftrekken, één 4-bituitgang en een carry-uitgang (in totaal dus een 5-bit uitgang) en een tekenbit-uitgang. Het blokschema bevat twee optellers, verschillede multiplexers en Boolese vergelijkingen om de uitgangen en de geïnverteerde ingangen te berekenen (neem dit blokschema op in je verslag). Implementeer deze module in VHDL in een entity addsub4. Gebruik de cla architectuur van je opteller. Pas nu je topniveau aan zodat je de add-sub module kan testen. Bij een positieve uitgang worden dezelfde 5 LEDs gebruikt om de som weer te geven. Bij een negatieve uitgang wordt het twee-complement van de 4 som-bits naar de eerste 4 LEDs gebracht. De vijfde LED wordt gebruikt als tekenbit. Verificeer het gedrag aan de hand van een automatische testbank. Aangezien je al geverificeerd hebt dat de opteller correct werkt, kan je je hier beperken tot het nemen van een aantal steekproeven met 9
optellen (met en zonder verwachte carry bit) en aftrekken (voor een positief en een negatief resultaat). Je kan nu voor elk geval het bitpatroon aan de ingang aanleggen en het bitpatroon aan de uitgang rechtstreeks vergelijken met het verwachte bitpatroon in plaats van het te berekenen. Implementeer het ontwerp vervolgens op het bordje en test het gedrag. 3.3.4 Omzetten van bitvectoren naar BCD-getallen Willen we nu de 5-bit getallen die uit de addsub4 module komen voorstellen als decimale getallen op de cijferdisplays. Hiervoor moeten we eerst een decoder maken die patronen van 5 bit omzet naar 2 BCD-getallen. In het algemene geval kan men dit doen door het quotient en de rest bij deling door 10 (bitpatroon 1010 ) te bepalen. Een deling van twee digitale getallen kan je implementeren op een gelijkaardige manier als een klassieke staartdeling, waarbij het resultaat bij deling nu enkel de waarden 0 of 1 kan aannemen. In dit geval is de situatie gelukkig eenvoudiger dan het algemene geval, aangezien de som van twee BCD-getallen maximaal 18 kan zijn. We zullen hier dus een rechtstreekse decoder maken (5-bit binair naar 2 x 4-bit BCD) aan de hand van een waarheidstabel met 18 ingangspatronen waarvoor de uitgang bepaald is. Voor de andere ingangspatronen is de uitgang don t care. Schrijf een VHDL-module die dit gedrag implementeert en verificeer aan de hand van een automatische testbank. Aangezien het aansturen van meerdere LED-displays via een sequentieel proces verloopt, zullen we deze module testen in het volgende hoofdstuk. 3.4 Rapportering Dien je VHDL-bestanden (zowel modules als testbanken) in samen met een kort verslag dat screenshots bevat van correcte simulatiegolfvormen (zonder- en met tijdsinformatie) en de antwoorden op de vragen die gesteld worden in de opgave. 10
Hoofdstuk 4 Sequentiële modules in het datapad 4.1 Doelstellingen In dit onderdeel implementeer je de sequentiële onderdelen van het datapad van je rekenmachine. 4.2 Voorbereiding Ter voorbereiding van dit practicum dien je te bestuderen hoe men sequentiële componenten beschrijft in VHDL, hoe men het gedrag van automaten kan specificeren aan de hand van een toestandstransitiediagram (syllabus en lesmateriaal) en hoe men deze beschrijving vervolgens kan omzetten naar VHDL-code (slides over VHDL). Zoals steeds word je geacht vertrouwd te zijn met alle gebruikte termen en begrippen, ook indien je de lessen niet hebt bijgewoond. 4.3 Opgave 4.3.1 De klok Vanaf nu zullen we synchrone componenten ontwerpen, waarvan één van de ingangen een kloksignaal is. Bij het verificeren van deze componenten in een testbank, zullen we hiervoor de klok gebruiken die in de testbank wordt gegenereerd. Bij de implementatie gebruiken we hiervoor de 100MHz klok die op de FPGA wordt gegenereerd. Start een nieuw project en importeer een blanco versie van het constraints-bestand (het bestand van Minerva). Activeer nu de drie lijntjes onder ##Clock signal: set property PACKAGE PIN W5 [get ports clk] set property IOSTANDARD LVCMOS33 [get ports clk] create clock -add -name sys clk pin -period 10.00 -waveform 0 5 [get ports clk] De eerste twee lijntjes zorgen ervoor dat op het topniveau het signaal clk wordt verbonden met de klok van de FPGA. Het derde lijntje zorgt ervoor dat de synthese- en de implementatiesoftware weten dat dit een klok is en dus zullen nagaan of aan alle voorwaarden voor correct synchroon gedrag is voldaan. 11
4.3.2 De display driver In een vorige opgave leerden jullie hoe je één enkel cijfer op de LED-display kan brengen. In wat volgt zullen we meerdere symbolen naast elkaar moeten kunnen weergeven. Zoals eerder aangegeven gebeurt dit door de 4 individuele displays één voor één aan te sturen. Door de erg lage bandbreedte van de LEDs (het aan- en uitschakelen gaat erg traag) moeten we dit veel trager doen dan de klokfrequentie van het systeem. In het bestand multiple display driver is dit geïmplementeerd. De entity heeft 16 ingangsbits (4 per display). Een twee-bit controlesignaal selecteert telkens de juiste 4 bits via een 4-naar- 1 multiplexer en de juiste waarde voor het anodesignaal. Om het overlopen van de 4 waarden van de twee selectie voldoende traag te laten verlopen, worden hiervoor de 2 meest significante bits van een 16-bit teller gebruikt. Bestudeer deze realisatie en tracht te begrijpen hoe ze werkt. Vraag: Hoe lang wordt elke individuele display aangestuurd bij een klokperiode van 10 ns? 4.3.3 Registers De meest eenvoudige sequentiële datapadcomponent is een register. Net als een flipflop heeft een register een klok-ingang, data-in- en uitgangen en één of meerdere controleingangen waarop het register synchroon (enkel bij stijgende klokflanken) of asynchroon (onmiddellijk) reageert. We zullen in dit practicum registers gebruiken met een asynchrone reset ingang en met een synchrone enable ingang. Bij hoge reset moeten alle bits in het register op 0 gezet worden. enable geeft aan wanneer het register zijn ingangen moet opslaan (hoge waarde) dan wel zijn huidige toestand moet beghouden (lage waarde). Beschrijf een entity Reg4 die een 4-bit register implementeert. Controleer aan de hand van een eenvoudige testbank (enkel behavioral simulatie met golfvormen) of je register correct reageert op het klok-, reset- en enable-signaal. 4.3.4 Componenten met variabele woordbreedte: generic parameters In de veel ontwerpen heb je componenten met éénzelfde gedrag nodig maar met verschillende woordbreedte. Om niet voor elke woordbreedte een nieuwe entity te moeten schrijven, biedt VHDL ook de mogelijkheid om parameters mee te geven aan een entity met behulp van de term generic. De declaratie van een entity die de bitsgewijze EN berekent van twee vectoren zou er bijvoorbeeld als volgt kunnen uitzien: entity and operator is generic( N : integer) port( A : in std logic vector(n-1 downto 0); B : in std logic vector(n-1 downto 0); O : out std logic vector(n-1 downto 0) ); end and operator; 12
Deze entity gebruik je dan in een andere module door de waarde van de parameter (hier gelijk aan 10) te specificeren als volgt: mijn and: entity work.and operator(architecture name) generic map( N => 10) port map( A => local signal1, B => local signal2, O => local signal3 ); waarbij de lokale signalen natuurlijk de juiste woordbreedte moeten hebben (10 in dit geval). Pas nu je register en je multiplexer aan zodat de woordbreedte geparameteriseerd wordt. De reset van je register zal je ook moeten aanpassen (waarom?). Je kan dit bijvoorbeeld doen door een constante te declareren en deze in je register op te slaan bij reset: constant zeros: std logic vector (N-1 downto 0) := (others => 0 ); 4.3.5 Een synchrone BCD op- en neerteller In wat volgt zullen we een module maken waarin we interactief een cijfer kunnen invoeren. De huidige invoer wordt weergegeven op de display driver. Door op het bovenste of het onderste knopje te drukken kunnen we dit cijfer telkens met één laten toenemen/afnemen (met zgn. wraparound als we bij 9, resp. 0 komen). Als we tevreden zijn met onze selectie kunnen we deze in een register opslaan door op het middelste knopje te drukken. Het overlopen van de waarden zullen we doen door een BCD-teller te maken die zowel omhoog als omlaag kan tellen. Net als het register moet deze component een asynchrone reset en een synchroon enable signaal hebben. De interpretatie is nu dat er enkel geteld wordt bij stijgende klokflank als enable hoog is. Daarnaast is er ook een ingang die aangeeft in welke richting geteld moet worden: hoog voor omhoog tellen, laag voor omlaag tellen. In principe kan je deze module beschrijven met de bouwblokken die je al gemaakt hebt, maar hier zullen we een eenvoudiger benadering volgen die in de praktijk, zeker bij FPGA s, meestal het beste resultaat geeft omdat ze de expertise die aanwezig is in de synthesetools maximaal benut. Realiseer het gedrag van de BCD-teller in een nieuwe entity. Kopieer onderstaande libraries in het entity-bestand van je BCD-teller: use ieee.std logic arith.all, ieee.std logic unsigned.all; Deze libraries leren aan de compiler hoe je kan rekenen met bitvectoren en maken deze berekeningen rechtstreeks synthetiseerbaar. Je kan nu het gewenste gedrag realiseren door te starten van onderstaand proces uit de allereerste testbank van de BCD-decoder: 13
process(clk,reset) begin if(reset= 1 ) then Interne teller <= "1111"; elsif rising edge(clk) then if Interne teller="1001"then Interne teller <= "0000"; else Interne teller <= Interne teller + "0001"; end if; end if; end process; Kopieer dit proces in de entity van je BCD-teller en pas het aan om het gewenste gedrag te realiseren. 4.3.6 De knopjes Het enige wat we nog moeten kunnen om de knoppen te gebruiken zoals hierboven beschreven is het loslaten van een ingedrukt knopje detecteren. Om een wijziging van een signaal te detecteren moeten we de vorige en de huidige waarde kunnen vergelijken. Hiervoor is geheugen nodig. We hebben dus een automaat nodig om het gewenste gedrag te realiseren. Deze heeft één uitgangsbit die hoog moet zijn gedurende precies één klokperiode nadat het knopje is losgelaten. Dit signaal kunnen we dan bijvoorbeeld gebruiken om de BCD-teller precies één tel omhoog of omlaag te laten tellen. Beschrijf in een nieuwe entity een synchrone automaat met asynchrone reset en één uitgangsbit. Als reset hoog is gaan we naar een wachttoestand waarin de uitgang laag is. Als reset hoog is wordt het volgend gedrag gerealiseerd: was de vorige toestand de wachttoestand, dan gaan we naar een toestand die de situatie van de knop weergeeft (ingedrukt/niet ingedrukt) en blijft de uitgang laag; was de knop niet ingedrukt en wordt hij nu wel ingedrukt dan gaan we over naar de toestand die hiermee overeenstemt en blijft de uitgang laag; was de knop ingedrukt en is dat nu niet langer het geval dan gaan we over naar een toestand waarin de uitgang hoog is - in deze toestand blijven we maar één klokcyclus en we gaan daarna over naar de toestand dieaangeeftdat de knop niet is ingedrukt. Teken het toestandstransitiediagram dat deze automaat beschrijft en neem het op in je verslag. Beschrijf deze daarna in VHDL in een entity button pressed en simuleer aan de hand van een automatische testbank. Zorg ervoor dat, bij het aanleggen van de ingang aan de automaat, het indrukken en loslaten van de klok niet samenvalt met klokflanken. Het gedrag van deze automaat is zo eenvoudig dat het niet zo veel zin heeft om een automatisch controlerende testbank te maken. Je mag het gedrag gewoon controleren op de golfvormen. 14
4.3.7 Test voor het invoeren van data Maak nu een topniveau VHDL bestand met als invoer de up, down en central knoppen en de klok en als uitvoer de signalen voor de LED-displays, led en an. Let erop dat de nodige lijntjes voor een topniveau-bestand actief staan zodat de in- en uitgangen effectief worden doorgekoppeld met de IO-pinnen. Gebruik de centrale knop als resetsignaal. Instantieer twee button pressed automaten met als ingangen de op- en neer-knoppen. Instantieer een BCD op-en-neerteller en combineer de signalen die uit beide knop-automaten komen om op correcte wijze de controlesignalen (enable en telrichting) van de teller aan te sturen. Instantieer de multiple-display-driver en stuur die aan met de juiste signalen zodat het te selecteren getal wordt weergegeven op een display van je keuze. Implementeer je ontwerp en test op het bordje. 4.4 Rapportering Dien je VHDL-bestanden in samen met een kort verslag dat screenshots bevat van correcte simulatiegolfvormen (zonder- en met tijdsinformatie) en de antwoorden op de vragen die gesteld worden in de tekst. 15
Hoofdstuk 5 Het datapad en de controller 5.1 Doelstellingen In dit onderdeel breng je alle onderdelen van het datapad samen en ontwerp je de controller voor de rekenmachine. 5.2 Voorbereiding Ter voorbereiding van dit practicum dien je de vorige opgaven te hebben afgewerkt. 5.3 Opgave 5.3.1 Het gedrag van de rekenmachine Met de onderdelen die we gemaakt hebben zullen we nu het gedrag realiseren waarbij achtereenvolgens volgende stappen doorlopen worden: We realiseren een synchroon ontwerp en gebruiken schakelaar 0 als resetsigaal. Na reset wordt op alle 4 de displays een minteken getoond. De gebruiker start een (nieuwe) berekening door op de centrale knop te drukken. Andere acties (behalve reset) van de gebruiker hebben geen effect. De gebruiker voert een eerste cijfer door op de bovenste en onderste knoppen te drukken tot wanneer het gewenste cijfer op de meest rechtse display staat en bevestigt zijn/haar keuze door op de centrale knop te drukken. Andere acties (behalve reset) van de gebruiker hebben geen effect. De gebruiker voert een tweede cijfer door op de bovenste en onderste knoppen te drukken tot wanneer het gewenste cijfer op de meest rechtse display staat en bevestigt zijn/haar keuze door op de centrale knop te drukken. Andere acties (behalve reset) van de gebruiker hebben geen effect. De gebruiker kiest een bewerking door de rechter (optellen) of linker (aftrekken) knop in te drukken. Andere acties (behalve reset) van de gebruiker hebben geen effect. 16
Het resultaat van de bewerking verschijnt op de display. Is het resultaat positief en kleiner dan 10, dan verschijnt er slechts één cijfer op de meest rechtse display. Is het resultaat positief en groter dan negen, dan worden de twee meest rechtse displays gebruikt. Is het resultaat negatief, dan wordt de meest rechtse display gebruikt voor het cijfer en de tweede display van links om een minteken weer te geven. Enkel het intoetsen van de centrale knop (start een nieuwe berekening) of een reset-signaal hebben een effect. 5.3.2 Datapad en controller Het datapad van onze rekenmachine heeft de volgende ingangen: Het 4-bit BCD-getal dat uit de BCD-teller komt (invoer van operandi) De button pressed signalen voor de centrale, linker- en rechterknop (controle, add, subtract) Het signaal van de meest rechtse schakelaar (gebruikt als reset) Het kloksignaal De nodige controlesignalen De uitgangen van het datapad zijn de aanstuursignalen van de display driver (16 bit data en 4 bit mask). In het datapad worden twee 4-bit registers gebruikt om de twee operandi op te slaan. Daarnaast is er natuurlijk een opteller/aftrekker nodig en de decoder die een 5-bitgetal omzet in twee BCD-getallen, enkele processen (evt. van één lijn) die de juiste signalen combineren en de juiste maskers maken voor de LED display driver en enkele multiplexers om te kiezen tussen uitgangen die van de getalselectie komen en uitgangen die van de berekening afkomstig zijn. Er zijn enkele eenvoudige bewerkingen die je naar keuze in de controller kan implementeren of door het datapad kan laten doen. In het laatste geval kan je hierdoor het aantal in- en/of uitgangen van je controller reduceren en dus de beschijving ervan vereenvoudigen. Teken eerst een blokschema van het datapad en maak een eerste schets van het toestandstransitiediagram van de controller (enkel de toestanden en wat ze betekenen). Ga vervolgens na welke signalen uit het datapad de controller moet observeren en noteer de voorwaarden voor elke toestandsovergang. Ga tenslotte na welke componenten uit het datapad controle-ingangen nodig hebben die afhankelijk zijn van de toestand van de controller en tracht het toestandstransitiediagram te vervolledigen met de juiste uitgangswaarden. Denk telkens na of je een Moore-gedrag of een Mealy-gedrag nodig hebt. Ga ook steeds na of je al dan niet tussentoestanden moet toevoegen in je toestandstransitiediagram. Dit kan bijvoorbeeld voorkomen als je binnen een bepaalde fase van het gedrag eerst één en dan een ander uitgangspatroon moet genereren. In de meeste gevallen kan je dit, behalve door het invoeren van een tussentoestand, ook realiseren door een decompositie waarbij een tweede eenvoudig automaatje gebruikt wordt om aan te geven in welke deelfase je zit. Overleg binnen de groep en zorg dat je volledig overtuigd bent van het correcte gedrag van het geheel op basis van je schema vooraleer over te gaan tot implementatie, dit om achteraf zo weinig mogelijk tijd te moeten besteden aan debuggen. 17
Realiseer de controller in een afzonderlijke entity. Neem in je verslag je finale toestandstransitiediagram van de controller op (zonder vermelding van de uitgangen) en een waarheidstabel waarin de uitgangen van je controller voor elke toestand (en evt. ingang) worden vermeld. Beschrijf ook het gedrag van je controller en de uitgangen die gerealiseerd worden in je verslag. 5.3.3 Verificatie met ROM-bestanden Vaak moet je testbank een vrij groot aantal ingangspatronen aanleggen en de uitgangen op het juiste tijdstip controleren. Bij het type testbank dat we tot nu toe gebruikt hebben zou dit te omslachtig worden. We zullen hier een nieuwe vorm van testbank leren gebruiken die gebruik maakt van een apart bestand met testvectoren (aangelegde ingangspatronen en verwachte uitgangen). Elke lijn van dit bestand bevat de ingangen die in één klokcyclus worden aangelegd en de uitgangen die aan het einde van dezelfde cyclus (dus bij de volgende klokflank) verwacht worden. Merk op dat dit betekent dat een dergelijke testbank enkel synchroon test en niet nagaat hoe een systeem reageert op ingangstransities tussenklokflanken door. Een sjabloon voor een dergelijk gedrag wordt geïmplementeerd in het bestand testbank rom.vhd met bijhorend ROM-bestand input vectors.txt. Dit laatste bestand moet je toevoegen aan je project als simulation source (vervang het bestandstype van VHDL naar memory file). Deze testbank voert een paar testjes uit op de automaat button pressed. De testbank is zó geschreven dat lijntjes in het ROM-bestand die beginnen met het symbool # als commentaar beschouwd worden. Gebruik bij het testen van complexere systemen met verschillende scenario s bij voorkeur dergelijke commentaar regels om je ROM-bestand te annoteren. Momenteel geeft deze testbank echter niet veel nuttige informatie bij het optreden van een fout. De ingangspatronen zijn hier immers zo simpel dat elk patroon meerdere malen optreedt. Het zou bijvoorbeeld veel zinvoller zijn mocht ze ook aangeven op welke lijn van de ROM-tabel de fout optreedt. Tracht deze testbank uit te breiden zodat ze meer zinvolle informatie geeft. Maak nu een entity calculator waarin datapad en controller van de rekenmachine worden samengebracht (dus NIET de I/O-modules). De ingangen van deze entity zijn het resetsignaal, de klok, de uitgangen van de knopmodules, en de uitgangen van de cijfer-selectiemodule. De uitgangen ervan zijn het 16-bitsignaal en het 4-bit masker die de ingangen vormen van de display-driver. Maak vervolgens een bestand met daarin de verwachte ingangs- en uitgangspatronen voor de rekenmachine. Doorloop daarbij verschillende keren het traject van één berekening. Je kan hiervoor een 10-tal berekeningen selecteren van dezelfde types (maar met lichtjes andere waarden) als diegene die je gebruikte in de testbank van de add-sub module. Beschrijf elke nieuwe berekening in een commentaar-regel. Laat ook af en toe gebeurtenissen optreden die overeenstemmen met ongeldige acties van de gebruiker: deze mogen volgens de specificaties geen gevolg hebben. Duid ook deze testen aan via commentaar regels. Gebruik je testbank om je ontwerp automatisch te controleren. Als je testbank fouten meldt, ga dan via de golfvormen na wat er misloopt. Bestudeer hiervoor niet enkel de externe signalen maar ook de inwendige signalen in je datapad en controller. Noot: Voor meer complexe toepassingen kan je met twee bestanden werken, bijvoorbeeld om controlesignalen en data-input te splitsen. Je kan vaak een extern script al deze bestanden automatisch laten genereren. In een beeldverwerkingstoepassing kan je 18
bijvoorbeeld ook het gegenereerde uitgangsbeeld wegschrijven om het resultaat visueel te kunnen analyseren. 5.3.4 Testen in hardware Maak tenslotte een nieuwe topniveau-entity waarin de module uit de vorige paragraaf gecombineerd wordt met de I/O-modules (de BCD-teller, 5 knopmodules en de multipledisplay-driver) en gekoppeld worden aan de nodige ingangen en uitgangen van het bord (de clk, 1 schakelaar, 5 knoppen en de LED-displays). Implementeer je ontwerp en test op het bordje. Als je ervan overtuigd bent dat het gedrag in hardware voldoet aan het beschreven gedrag, laat je finale realisatie controleren/evalueren door de prof. of een begeleider. 5.4 Rapportering Dien je VHDL-bestanden en testbanken in samen met een kort verslag dat screenshots bevat van correcte simulatiegolfvormen, de automaatbeschrijvingen (toestandstransitiediagrammen), een structuurdiagram van je finale ontwerp en een bespreking ervan. Geef ook uitleg bij je keuzes op die plaatsen waar verschillende alternatieven mogelijk waren. 19