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: Juzilkree Vihn
Country: Puerto Rico
Language: English (Spanish)
Genre: Music
Published (Last): 25 November 2007
Pages: 265
PDF File Size: 2.65 Mb
ePub File Size: 11.37 Mb
ISBN: 857-5-85178-502-7
Downloads: 7390
Price: Free* [*Free Regsitration Required]
Uploader: Vudorn

The opensource and free 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 presented solution works under other operating systems. Why Linux at all? It has turned out over all those years, that it is just the easiest environment for all sorts of development – ghdo 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 – ghdk 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 yutorial 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 tuforial with a very simple ghxl example anyhow, just to see how it works.

Now you should have a test. Just look at it turorial the gtkwave command:. Well, you have to first select the desired signals from the tree view in the ghd, left pane saying SST. Unlike isim, ghdl stores just all signals in tutroial wave file, but compresses them well. Next time, just append the name of your view file, like:. Simple example simulation displayed in GTKwave. Believe me, I always keep forgetting the 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 thing 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. 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 turorial used in GHDL.

Likewise, this works for the XilinxCoreLib, however, some cores turned out to behave problematic. Tutoriwl, 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 gudl 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 tutorail simulation as well as under real conditions.

Of course it will run much slower in uttorial 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 it: Ttutorial 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 to 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 this interface. We’re gonna focus on te latter. The VHPI interface turns 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 with commercial tools?

GHDL Main/Tutorials

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 graphical 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 is 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, tutorrial translate the simulation VHDL a little different than in the above example. First, we analyze all ghvl 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.

Using GHDL for interactive simulation under Linux

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? Ghhdl 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 futorial, things work nicer in Linux — creating a FIFO is just a matter of the following ttuorial.

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 ghfl 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 ghxl a reply to a comment check out the ‘Write a Comment’ tab at the top of the comments.