A quickstart to GHDL and GTKWave. 0. It is assumed that the design and testbench are created at this point. 1. Launch a console window. 2. Navigate to the. Tutorials about GHDL. This section is under development. Search. Home · Features · Download · Installation · User Guide · Tutorials · VHDL · FAQ · Report a bug. GHDL is an open-source simulator for the VHDL language. GHDL allows you to compile and execute your VHDL code directly in your PC. GHDL fully supports.

Author: Gujind Tuhn
Country: Cameroon
Language: English (Spanish)
Genre: Politics
Published (Last): 3 January 2007
Pages: 307
PDF File Size: 7.91 Mb
ePub File Size: 11.13 Mb
ISBN: 256-7-82508-307-2
Downloads: 30966
Price: Free* [*Free Regsitration Required]
Uploader: Arashigul

The opensource and tutoriial VHDL simulator ‘GHDL’ has been out for many years, but like many other opensource tools, it has caught limited attention from the industry. I can hear you thinking: Well, I hope this short overview will change your mind and even whet your appetite for more. Because, using some extensions, you can do some quite funky stuff with it that will save you a lot of debugging work.

For example, simulate your real world software with a virtual FPGA device. This can be beneficial to:. This article is kind of “Linux only”.

Although there is a GHDL version for Windows, I have no clue how well the thdl solution works under other operating systems. Why Linux at all? It has turned tutorrial over all those years, that it is just the easiest environment for all sorts of development – for me at least. The Xilinx toolchain for example was found to run much faster under Linux than Windows for unknown reasons.

Ok, so what is GHDL really? It’s been somewhere within my attention horizon for years, but I never seriously used it so far – until a few weeks ago. This doesn’t make me an expert yet, but that would actually speak for GHDL. Considering myself old fashioned when it comes to development of reliable designs, I hardly tend to migrate. You might have been repelled by the fact that there is very sparse documentation available about GHDL and you have to do the time consuming scattered-post-picking from all the mailing lists.

Let us just try to change that – a little. You also might have been aware that GHDL is ‘just’ a plain simulator that can output into wave files. The actual wave display is a seperate thing, but covered up nicely by the gtkwave application. You simply run your simulation executable with some output options, re- load the wave file within gtkwave and you’re set with a fast and convenient wave display.

For all other distributions or systems, check the official GHDL website http: There are plenty of tutorials around, but we’ll start with a very simple standalone example anyhow, just to see how it works.

GHDL Main/Tutorials

Now you should have a test. Just look at it using the gtkwave command:. Well, you have to tutorkal select the desired signals from the tree view in the upper left pane saying SST. Unlike isim, ghdl stores just all signals in the wave file, but compresses them well. Next time, just append the name of your view file, like:.

Simple example simulation displayed in GTKwave. Believe tutorixl, I always keep forgetting ghd, gory details why, but let’s just agree on they are “dirty” and read about all the details elsewhere. However, Xilinx for example uses those dirty references all over the place, so we need to rely on it if we want to simulate their primitives. But let’s emphasize one tutorixl first: Anyhow, there are various options to make GHDL accept your or other people’s code using various flags like –std, or the –ieee options.


These are in fact quite well documented. When migrating from your code that is for example verified to work using Isim, you may still have to do some adaptations to GHDLs strict standard interpretation, depending on how ‘clean’ your code is.

Quick Start Guide — GHDL dev documentation

That sounds like another reason to be sceptic about GHDL, but then again, it became pretty darn good at pointing out errors over all these years, so you should have no problem boiling down the error report to a few warnings and end up with sane VHDL code.

Really, I expect the tools to teach me the standard, not page reference manuals. So you are ready to tackle a larger project and you have a bit of time, right?

Before we just rephrase what we learnt from another source, we’ll simply link it to this very useful paper describing in short words how Unisim components can be used in GHDL. Likewise, this works for the XilinxCoreLib, however, some cores turned out to behave problematic. Anyhow, here it is:. Assuming you have verified your simulations for many years using various simulators, you’ll probably nod at the following development process:.

So the obvious question is: How can this simulation technique be improved? Instead of shoveling many static test vectors and data files into our simulation, couldn’t we just make our projected software speak directly to the simulation?

If we design a certain framework right, chances are high that we end up with a solution that works in the simulation as well as under real conditions. Of course it will run much slower in the simulation, but so what, we can run the entire test bench over night.


The first question for the OpenSource linux hacker might be, after doing the first steps with a program and liking hgdl How can it be extended with own code? Then the next thought might be: But I don’t want to touch a framework in a language I’m not firm in ok, Ada is similar tutprial VHDL, but we got used to program hardware with it, not software. It turns out, since it’s all GCC, that there is some more or less convenient calling convention, so we can – in theory – easily extend the generated simulator code with own library routines.

This is nothing new, you will find out that quite a few commercial simulators have tutoriap interface. We’re gonna focus on te latter.

The VHPI interface gndl out to be quite simple: However, the interface and calling conventions are just not too well documented, as they might be subject to change This is what the GHDL documentation tells us. So note that we are proceeding into a kind of hackish area: Noone will guarantee, that our extensions work in 10 years without change.

But then again, would you get that stability ghel commercial tools? I don’t think so. So let’s proceed, we want to see a solution until dawn. One resource that has boosted this development a lot, is Yann Guidon’s collection of extensions at http: Among other nice solutions, he demonstrates how a simulation can be run in real time, how data can be read from the parallel port or how tutoriql data can be displayed on a linux frame buffer.


Let us take Yann’s “bouton” Push button example. It polls the pins from a parallel port device under linux. For that, you’d define a function prototype in VHDL, but with some special attributes as follows:. We are not done yet, this thtorial just the prototype.

We’ll also need some kind of function stub to actually wrap our code. In the same file, you’ll find a package body:.

That is the VHDL side. The C side is much shorter, here’s the prototype for our button read function:. So you can see that the above buttons map into a char array. But what’s contained in these chars? There can be a few more states like ‘X’, ‘U’, ‘Z’. The encoding is listed in the ghpi. It actually makes sense to collect all these C extensions in a library and link them, like you’ve possibly done that in GCC many times.

So we’ll first create a library with all the extensions:. Then, we’ll translate the simulation VHDL a little different than in the above example. First, we analyze all the files, then we explicitely elaborate and link against the simulation with the ghdl -e command, but specifying link options:. You’d probably want to put these commands into a Makefile.

We have found so far, using Yanns examples, that we can call stuff from the GHDL simulation repeatedly, but we can not easily make a C program control the entire simulation in the sense of being a ‘master’. But rethinking this wish, makes us probably realize that in real world we don’t have this situation: Why don’t we just mimic this? The simplest FIFO implementation we can think of, is the one that we don’t have to code ourselves. Even Windows would offer Pipes, but due to the unified filesystem nature of things in Unix like systems, things work nicer in Linux — creating a FIFO is just a matter of the following command:.

What you write into this file, is read again from the other side. Before we bore you with another program listing, you might be inclined to download our GHDL extensions. As you can see, we have defined some handle and flag types. Makes coding easier, once you change things, so it makes sense to use those type definitions. Normally, you’d call this function from a clock sensitive process and use a global signal to save the status flags.

But here we’d come to the point where we say: Read the source, Luke. Or compile again, Sam. There’s more to it: It’s just a file! However, as soon as it comes to networking, there are cleaner and nicer ways to do it, and here we lead over to the drawbacks of pipes:. Workarounds are possible, but there are various reasons why we shouldn’t bother and move on to a FIFO solution.

For now though, we will end here and postpone the FIFO talk to a possible next article To post reply to a comment, click on the ‘reply’ button attached to each comment. To post a new comment not a reply to a comment check out the ‘Write a Comment’ tab at the top of the comments.