A Tutorial: Getting Started With Digital Circuit Simulation
A Tutorial: Getting Started With Digital Circuit Simulation
A Tutorial: Getting Started With Digital Circuit Simulation
A Tutorial
Getting Started with Digital Circuit Simulation
Mike Brinson
Copyright
c 2006 Mike Brinson <mbrin72043@yahoo.co.uk>
Permission is granted to copy, distribute and/or modify this document under the
terms of the GNU Free Documentation License, Version 1.1 or any later version
published by the Free Software Foundation. A copy of the license is included in
the section entitled ”GNU Free Documentation License”.
Introduction
On 21 January 2006 Qucs 0.0.8 was released by the Qucs development team. This
is the first version of the package to include digital circuit simulation based on
VHDL. FreeHDL1 being chosen as the VHDL engine. In the period following the
release of Qucs 0.0.8 there has been considerable activity centred around finding
and correcting a number of bugs in the Qucs digital simulation code. Many of these
fixes are now included in the latest CVS code and will eventually form part of the
next Qucs release. This tutorial note is an attempt on my part to communicate
to other Qucs users a number of background ideas concerning the capabilities and
limitations of the current state of Qucs VHDL simulation. Much of the information
reported here was assembled by the author while assisting Michael Margraf to test
and debug the VHDL code generated by Qucs. In the future, if there is enough
interest in these notes, or indeed in Qucs VHDL simulation in general, I will update
them as the Qucs digital simulation features are improved.
Qucs digital simulation follows a complex set of steps that are mostly transparent
to the software user. In step one, a schematic representing a digital circuit under
test is drawn. This schematic consists of an interconnected group of Qucs digital
components, one or more user defined digital subcircuits (if required), and a copy
of the digital simulation icon with the timing or truth table parameters set. In
step two, the information recorded on a circuit schematic is converted into a text
file containing VHDL statements. These describe the circuit components, their
connection, and a testbench for simulating circuit performance. Next, FreeHDL is
launched by Qucs to convert the VHDL code file into a C++ source program. This
is compiled to form an executable machine code simulation of the original circuit.
Finally, Qucs runs this program, collects signal data as digital signal events take
place and displays signal waveforms as a function of time or digital data in a truth
table format.
The VHDL code generated by Qucs 0.0.8 is limited in its scope by the following
factors:
• Flip-flops and the digital signal generator are described by process state-
ments.
1
• Digital bus structures are not allowed in this release of the Qucs package.
• Digital subcircuit pins can have type in, out, inout or analog. Qucs treats
pins of type analog the same as VHDL pin type inout.
• Once defined digital subcircuits may be placed and connected to other com-
ponents on schematics.
• Multiple copies of the same digital subcircuit are allowed on a single schematic.
• Digital subcircuits may also be nested; nesting has been tested to a depth of
four.
A B C F
0 0 0 0
0 0 1 1
0 1 0 1
0 1 1 0
1 0 0 0
1 0 1 1
1 1 0 1
1 1 1 0
Table 1: Truth table for a logic circuit with inputs A, B, C and output F.
2
On minimisation, using Boolean algebra or a Karnaugh map, output F becomes
F = A.C + B.C
The schematic for example 1 is illustrated in Fig. 1. This diagram was constructed
using the same techniques employed for drawing analogue schematics.
• A useful tip when drawing digital schematics is to adopt the matrix approach
shown in Fig. 1. Input signals flow from top to bottom of the schematic and
output signals are positioned on the right-hand side of a horizontal line.
This makes checking the circuit schematic for errors much easier than the
case where diagrams have wires connecting components in an unstructured
way.
• Input and output wires (signals) should be given names consistant with the
circuit being simulated, A, B, C and F in Fig. 1. If the signal wires are
not named by the user, Qucs will allocate them different arbitrary names.
This can make identification and selection of signals for display on an output
waveform graph, and indeed checking for errors in a large circuit, much more
difficult than it need be.
• Notice in Fig. 1 the international symbols for the logic gates are shown on
the schematic.
3
A B C
digital
simulation
Y1
1
Digi1
A B
Type=TimeList
C
time=200ns
&
1 F
CB Y2
Y4
&
Y3
Signals identified by nnnet0 and nnnet1 in Table 2 have been allocated these names
by Qucs; nnnet0 and nnnet1 are internal signal nets that are not named on the
circuit schematic shown in Fig. 1. Fig. 2 illustrates the starting section of a typical
Qucs digital functional waveform plot. This style of plot illustrates signal events
without component delays. If required, signal delays can be specified for individual
gates and other components (from the component edit properties menu). The
VHDL code generated for components with delays will then reflect such changes,
for example adding a 10 ns delay to signal CB in Table 2 generates VHDL code
CB <= not C a f t e r 10 ns ;
Readers will probably have observed that the Qucs version number referred to
in Table 2 VHDL listing is 0.0.9. This is the current CVS development version
number. Qucs 0.0.9 includes a number of important bug fixes. The remainder of
these notes assume readers have downloaded, and recompiled, the latest CVS code
4
−− Qucs 0 . 0 . 9 t u t 1 e x 1 . s c h
entity TestBench i s
end entity ;
use work . a l l ;
A: process
begin
A <= ’ 0 ’ ; wait f o r 40 ns ;
A <= ’ 1 ’ ; wait f o r 40 ns ;
end process ;
B : process
begin
B <= ’ 0 ’ ; wait f o r 20 ns ;
B <= ’ 1 ’ ; wait f o r 20 ns ;
end process ;
C: process
begin
C <= ’ 0 ’ ; wait f o r 10 ns ;
C <= ’ 1 ’ ; wait f o r 10 ns ;
end process ;
end architecture ;
5
from Sourceforge.net3 .
dtime 0 10n 20n 30n 40n 50n 60n 70n 80n 90n 100n 110n 120n 130n 140n 150n 160n 170n 180n 190n 200n
a.X
b.X
c.X
f.X
Truth tables
Truth tables are one of the most fundamental and convenient ways of displaying
digital circuit data. Qucs has a built-in facility that allows a truth table to be
generated from a schematic drawing. This feature is particularly useful when
checking minimised logic designs for errors. Lets consider a simple but instructive
example: A logic circuit has four binary inputs A, B, C, and D, and one output
P. Output P is logic ’1’ when inputs ABCD are numbers in the decimal sequence
3, 5, 7, 11 and 13. In Boolean sum of product form
P = D.(A.B + B ⊕ C)
3
Please note, Qucs Linux release 0.0.8 will normally simulate single hierarchy digital circuits
without error. However, Qucs 0.0.8 does fail at the VHDL to C++ conversion phase if a schematic
includes more than one ground symbol.
6
A B C D
digital
A Y1 B
Y2 C Y3 D simulation
1
Digi1
Type=TruthTable
&
Y6
&
1
P
Y7
& Y10
Y8
&
Y9
&
Y11
A B C D digital
D
A B C simulation
Y3
Digi1
1
Type=TruthTable
&
1
& P
Y7
Y8
=1 Y6
Y4
7
3(a): Truth table for sum of products
equation P
a.X b.X c.X d.X p.X
00000 0 0 0 0 0
00001 0 0 0 1 0
00010 0 0 1 0 0
00011 0 0 1 1 1
00100 0 1 0 0 0
00101 0 1 0 1 1
00110 0 1 1 0 0
00111 0 1 1 1 1
01000 1 0 0 0 0
01001 1 0 0 1 0
01010 1 0 1 0 0
01011 1 0 1 1 1
01100 1 1 0 0 0
01101 1 1 0 1 1
01110 1 1 1 0 0
01111 1 1 1 1 0
8
Digital subcircuits
Although it is possible to draw complex schematic diagrams using only the pre-
defined digital components supplied with Qucs, this technique can be extremely
tedious, and is of course, prone to error. When drawing large schematics we re-
quire a design procedure that naturally subdivides groups of digital components
into self contained units. These units can then be treated in the same way as
basic digital components when placing and connecting them on a schematic draw-
ing. In the world of analogue and digital circuit design such units are often called
subcircuits.4 A subcircuit is defined by three major attributes plus a number of
other properties. The major attributes are, firstly a digital circuit that defines
circuit function, secondly a circuit symbol that depicts a circuit in a higher level
of a design hierarchy, and thirdly the subcircuit input/output pins shown on the
subcircuit symbol. Other properties include for example, signal path delays. The
process for generating digital subcircuits is identical to that used for analogue sub-
circuits. It is best demonstrated by considering an example. Figure 4 shows the
schematic for a four input combinational circuit.
After drawing a subcircuit schematic, input and output5 pins are attached to signal
ports. Input port pins of type in are shown on circuit diagrams as a green symbol,
signals W, X, Y, and Z, in Fig. 4. Ouput port pins of type out are coloured red,
signal G in Fig. 4. Signal flow through a port is indicated by the direction of the
port symbol arrow head. Input/output signals, and any other signals that need
to be easily identified, are also named. Once the subcircuit schematic is complete,
pressing key F3 causes Qucs to generate a subcircuit symbol. The drawing tools
listed as icons in the Qucs paintings window can be used to edit Qucs generated
subcircuit symbols. The input/output port pins on a subcircuit symbol have the
same type and name as those on the original subcircuit schematic. Fig. 5 shows
the finished symbol for subcircuit COMB1. In these notes, symbol outlines are
shown drawn in accordance with the international code for logic symbols6 . To test
our new subcircuit we place it’s symbol on a blank drawing sheet and apply test
signals to the input pins and observe the signals at the output pin. Fig. 6 shows a
typical test circuit. Subcircuit Gen4bit generates a 4 bit test pattern synchronised
4
The circuit simulator SPICE is a well known example of a widely used CAD program that
makes extensive use of subcircuits in circuit design.
5
Qucs 0.0.8 has a bug which causes a VHDL compile error when subcircuit pins are specified
as type out. A work around for this bug is to specify subcircuit output pins as type analog. The
Qucs routines that generate the circuit VHDL code convert pin type analog into VHDL type
inout. FreeHDL is then able to compile the generated VHDL code without error. This bug has
been corrected in Qucs 0.0.9.
6
Ian, Kampel, A practical introduction to the new logic symbols, Butterworths, 1985, ISBN
0-408-01461-X.
9
Z Y X W
Y
Y3 Y2 Y1
1
Z XB
YB
& IN1
Y4
X WB
IN2
&
1 G
Y5
G
Y8
& IN3
Y6
& In4
Y7
to the input of a digital clock. The specification for Gen4bit is given in the next
section of these notes7 . The test pattern waveform and output signal G are shown
plotted as a function of time in Fig. 7.
7
Subcircuit Gen4bit includes other nested subcircuits. Qucs 0.0.8 has a bug that causes
VHDL compile errors with some configurations of nested subcircuits. This has been fixed in
version 0.0.9.
COMB1
W W
X X
G G
Y Y
Z Z
SUB
File=name
Figure 5: Qucs symbol for a logic circuit with inputs W, X, Y, Z, and output G.
10
R B0 COMB1
R B0 W
B1 B1
R
times=5ns; 1sec B2 X
G
B3 B2 G
CLOCK Y
CLOCK
times=10ns; 10ns Gen4bit B3
Z
SUB2
File=gen4bit.sch
SUB1
digital File=dtut1_ex2.sch
simulation
COMB1
Type=TimeList
time=1000 ns
Figure 6: Test schematic for a logic circuit with inputs W, X, Y, Z, and output G.
11
dtime 5n 10n 20n 30n 40n 50n 60n 70n 80n 90n 100n 110n
r.X
clock.X
b0.X
b1.X
b2.X
b3.X
g.X
12
Building a digital component library
The Qucs graphical user interface includes good project handling features. Com-
bining these features with the Qucs subcircuit capabilities provides all the tools
required for the development of a library of common digital components. Such
a library can be stored in a master project and the individual component files
imported into other projects when required. Here are a few components that I
developed during a recent series of tests aimed at detecting bugs in the VHDL
code generated by Qucs.
Logic zero
L0
L0 0
SUB
File=name
Logic one
L1 1 1 L1
L1
SUB
File=name Y1
CLK B1 B1
Gen2bit
SUB
File=name
13
B0
JK B0
1
SUB1
0 B1
SUB2 B1
J S Q J SQ
CLK
B1b
CLK K R Q K R Q
B0b
R FF0 FF1
RES
R R B0 B0
B1 B1
B2 B2
CLK B3 B3
Gen4bit
SUB
File=name
B0 B1 B2 B3
B0 B1 B2 B3
1
SUB1
CLK
J S Q 0 J S Q J S Q J S Q
SUB2
CLK K R Q K R Q K R Q K R Q
Q0B Q1B Q2B Q3B
FF0 FF1 FF2 FF3
R
JK
14
MUX2to1 - 2 input to 1 output multiplexer
EN A Y
1 X L
0 0 D0
0 1 D1
MUX
ENB EN
A 0}G 0
Y
1
D0 0
D1 1
SUB
File=name
A 1
&
A Y
Y1 1 Y
Y2
D0
& Y4
D0
D1
Y3
D1
15
MUX4to1 - 4 input to 1 multiplexer
B A EN Y
X X 1 0
0 0 0 D0
0 1 0 D1
1 0 0 D2
1 1 0 D3
MUX
ENB EN
A 0
B
}G 0
1 3
Y
D0 0
D1 1
D2 2
D3 3
SUB
File=name
D3 D2 D1 D0 B A ENB
ENB
Y8 Y7 Y6
1
EN
AB &
B BB A
Y1
D2 D1 D0
D3 &
1 Y
Y
Y2
& Y5
Y3
&
Y4
16
Σ
Σ
2 bit adder
A1 0
B1 1
}A
0 S1
{
1 S2
A2 0
}B
B2 1
CI CI CO C0
SUB
File=name
CI B2 A2 B1 A1
=1 S1
S1
Y1
&
CI B2 A2 B1 A1 1
Y4
& Y7
=1
Y5
Y10
=1 S2
S2
Y2
&
=1
C0
1 CO
Y8
Y6
& Y3
Y9
Gen2bit
17
entity S u b g e n 2 b i t i s
port (CLK: in b i t ;
R: in b i t ;
nnout B0 : out b i t ;
nnout B1 : out b i t ) ;
end entity ;
use work . a l l ;
architecture A r c h S u b g e n 2 b i t of S u b g e n 2 b i t i s
s i g n a l B0b ,
B1b ,
JK ,
nnnet0 ,
B0 ,
B1 : b i t ;
begin
FF0 : process ( nnnet0 , R, CLK)
begin
i f (R= ’1 ’) then B0 <= ’ 0 ’ ;
e l s i f ( nnnet0 = ’1 ’) then B0 <= ’ 1 ’ ;
e l s i f (CLK= ’1 ’ and CLK’ e v e n t ) then
B0 <= (JK and not B0 ) or ( not JK and B0 ) ;
end i f ;
end process ;
B0b <= not B0 ;
2 bit adder
entity S u b f a d d 2 b i t i s
18
port (A1 : in b i t ;
B1 : in b i t ;
A2 : in b i t ;
B2 : in b i t ;
CI : in b i t ;
nnout S1 : out b i t ;
nnout S2 : out b i t ;
nnout CO : out b i t ) ;
end entity ;
use work . a l l ;
architecture A r c h S u b f a d d 2 b i t of S u b f a d d 2 b i t i s
s i g n a l nnnet0 ,
nnnet1 ,
nnnet2 ,
nnnet3 ,
nnnet4 ,
nnnet5 ,
nnnet6 ,
S2 ,
CO,
S1 : b i t ;
begin
S1 <= CI xor B1 xor A1 ;
nnnet0 <= B2 xor A2 ;
nnnet1 <= nnnet0 and nnnet2 ;
nnnet3 <= B2 and A2 ;
nnnet2 <= nnnet4 or nnnet5 ;
nnnet4 <= nnnet6 and CI ;
nnnet5 <= B1 and A1 ;
S2 <= B2 xor A2 xor nnnet2 ;
CO <= nnnet3 or nnnet1 ;
nnnet6 <= B1 xor A1 ;
nnout S2 <= S2 or ’ 0 ’ ;
nnout CO <= CO or ’ 0 ’ ;
nnout S1 <= S1 or ’ 0 ’ ;
end architecture ;
19
• Type out entity port signals are prevented from being read as input signals
by masking each output signal using the logic function signal-name OR
’0’.8
• A VHDL
use work . a l l ;
• The complete VHDL code file for a digital design is composed from an outer
test bench entity-architecture model plus entity-architecture models for each
subcircuit specified in the design,
8
Attempting to read entity port signals of type out results in a VHDL compile error.
9
Strictly speaking it should not be necessary to specifically state the use of the work library as
this library is normally visible at all times when compiling entity-architecture models. However,
at this stage in the development of FreeHDL it does appear that it is necessary when using the
default FreeHDL VHDL library mapping.
20
4 bit RTL design
CONTROL1
0 LOAD
REG 4bit 1
R2Q0
1 R2D SUB1
D0 Q0
R2Q1 File=quad_mux2to1.sch SUB2
SUB14 D1 Q1 File=reg_4bit.sch
R2Q2
D2 Q2 R2Q3
D3 Q3
SUB4 Digi1
File=reg_4bit.sch Type=TimeList
time=1000 ns
Reg4bit
REG 4bit
D0 D0 Q0 Q0
D1 D1 Q1 Q1
D2 D2 Q2 Q2
D3 D3 Q3 Q3
LOAD LOAD
CLOCK
SUB
File=name
21
D0
D
Q0
D0 Q0
Num=1 EN
SUB1
File=d_flip_flop_l.sch
D1
D
Q1
D1 Q1
Num=2 EN
SUB2
File=d_flip_flop_l.sch
D2
D
Q2
D2 Q2
Num=3 EN
SUB3
File=d_flip_flop_l.sch
D3
D
Q3
D3 Q3
Num=4 EN
LOAD
LOAD SUB4
Num=5 File=d_flip_flop_l.sch
CLOCK
CLOCK
Num=6
22
D flip-flop with load enable
D D
EN EN Q
CLOCK
SUB
File=name
EN Mux2to1
0 G 0
1 Q Q
EN
0 D Q
D R
1
D SUB1 Y1
File=mux2to1.sch
0
CLOCK
CLOCK
SUB2
File=logic_zero.sch
Mux2to1
Mux2to1
A 0 G 0
1
D0 0 Y
D1 1
SUB
File=name
A
1
& Y
A Y
Num=4
Num=1 Y1 1
D0 Y2
& Y4
D0
Num=2 D1
Y3
D1
Num=3
23
QuadMux
0
SEL 0} G
1
A0 MUX
0 Y0
B0
1
A1 0 Y1
B1 1
A2 0
Y2
B2 1
A3 0
Y3
B3 1
SUB
File=name
Mux2to1
Y0
0 G 0
1 Num=10
SEL
Num=1 0
A0
Num=2 1
B0 SUB1
Num=6 File=mux2to1.sch
Mux2to1
Y1
0 G 0
1 Num=11
0
A1
Num=3 1
B1 SUB2
Num=7 File=mux2to1.sch
Mux2to1
Y2
0 G 0
1 Num=12
0
A2
Num=4 1
B2 SUB3
Num=8 File=mux2to1.sch
Mux2to1
Y3
0 G 0
1 Num=13
0
A3
Num=5 1
B3 SUB4
Num=9 File=mux2to1.sch
24
dtime 370n 380n 390n 400n 410n 420n 430n 440n 450n 460n 470n 480n 490n 500n 510n 520n 530n 540n 550n
clock.X
control1.X
control2.X
load.X
r1q0.X
r1q1.X
r1q2.X
r1q3.X
r2q0.X
r2q1.X
r2q2.X
r2q3.X
r3d0.X
r3d1.X
r3d2.X
r3d3.X
r3q0.X
r3q1.X
r3q2.X
r3q3.X
25
• Multiple input gates (three or more inputs) of types nand and nor failed at
the FreeHDL compile stage due to an error in the VHDL code generated by
Qucs.
• Signals names and, for example, component names constructed from a single
letter that was an abbreviation for a physical unit failed to compile.
• GUI problems caused by errors in the symbol rotation and mirror code.
• Qucsconv code conversion errors caused the Qucs digital simulation cycle to
fail before plotting TimeList waveforms.
A number of changes to either the VHDL code generated by Qucs or the schematic
capture GUI have been introduced, these include
• The VHDL code generated by Qucs for the ground symbol has been changed
from
gnd <= gnd and ’ 0 ’ ;
to
gnd <= ’ 0 ’ ;
• The symbol for digital inout ports has been changed from the analogue pin
symbol to one that consists of the digital in and out pins drawn back-to-back.
This reflects the bidirectional status of an inout port.
A more complete list of all the bug corrections and other program modifications
can be found in the Qucs change log files.
26
1. Schematic circuit entry using predefined digital component symbols, subcir-
cuits generated using the same symbols and a copy of the digital simulation
icon; this is the approach described in the first version of these tutorial notes.
3. Circuit entry using the Qucs VHDL code editor. The text entered describes
both the circuit under test and the test vectors needed to drive the circuit
inputs during simulation.
Once the circuit under test has been entered into Qucs, clicking the Simulate menu
button, or pressing key F2, starts the Qucs digital simulation process.
Limitations
Before describing the new digital simulation features it is important that readers
understand the limitations that are inherent in the various digital simulation routes
described in the last section and illustrated in the flow diagram shown in Fig. 10.
Qucs schematic capture allows users to draw circuits consisting of predefined com-
ponent symbols and subcircuit symbols. At this stage in the development of the
GUI digital signals must be of type bit (as defined in the VHDL standard library
- library STD in the FreeHDL package) where individual signals flow through a
single wire. Qucs schematic drawing bus structures of VHDL type bit-vector, for
example, have not been implemented yet. This implies that the device symbol port
pins must represent single signals. Similarly the nets connecting pins on more than
one device can only be single signal nets and not bus structures. It is anticipated
that this will change in a future Qucs release.
Although the current release of FreeHDL is 0.0.1 the package implements a sub-
stantial subset of the entire VHDL language11 . The major features not supported
by release 0.0.1 are:
• Shared variables.
• Groups.
11
A complete description of the 1987 and 1993 specifications of the VHDL language can be
found in The Designer’s Guide to VHDL by Peter J Ashenden, second edition 2002, Morgan
Kaufmann Publishers, ISBN 1-55860-674-2.
27
VHDL Generate Predefined Qucs
entity/architecture VHDL digital component
code model symbol symbols
Qucs GUI
Digital
VHDL
subcircuit
STD VHDL testbench Circuit drawing symbols
library code
elements Entered using Qucs Generated
Entered using schematic capture using Qucs
Qucs VHDL schematic capture
editor
SIMULATE
Simulation
Output
data
Qucs Truth Table
View
28
• Guarded signal assignments.
• Currently drivers cannot be switched off.
The Qucs TimeList plotting program uses signal data output by the machine code
simulation program generated by the FreeHDL package12 . A current limitation of
the TimeList plotting program is that it can only display signals of type bit. Bus
signal waveforms cannot be displayed.
Given the above limitations it is therefore possible to write VHDL code that can
be compiled by FreeHDL but will cause problems at either the schematic drawing
or output waveform plotting stages in the Qucs simulation cycle. As Qucs develops
it is expected that these limitations will be removed. On the subject of limitations
one final point to note: FreeHDL can simulate circuits described by the data types
and other features found in the
IEEE.std_logic_1164
library and other predefined libraries. However, at this stage in the development
of the Qucs software only the VHDL standard library may be used, implying that
data type bit must be used to represent logic signals.
29
• Example 1: A sum of products (SOP) combinational digital circuit.
The Boolean equation15 for a SOP combinational circuit is:
30
port ( in1 , in2 , in3 , i n 4 : in b i t ;
out1 : out b i t
);
end entity and4 ;
−−
architecture d a t a f l o w of and4 i s
begin
out1 <= i n 1 and i n 2 and i n 3 and i n 4 ;
end architecture d a t a f l o w ;
−−
entity and3 i s −− 3 i n p u t and g a t e .
port ( in1 , in2 , i n 3 : in b i t ;
out1 : out b i t
);
end entity and3 ;
−−
architecture d a t a f l o w of and3 i s
begin
out1 <= i n 1 and i n 2 and i n 3 ;
end architecture d a t a f l o w ;
−−
entity o r 4 i s −− 4 i n p u t or g a t e .
port ( in1 , in2 , in3 , i n 4 : in b i t ;
out1 : out b i t
);
end entity o r 4 ;
−−
architecture d a t a f l o w of o r 4 i s
begin
out1 <= i n 1 or i n 2 or i n 3 or i n 4 ;
end architecture d a t a f l o w ;
entity i n v i s −− I n v e r t e r .
port ( i n 1 : in b i t ;
out1 : out b i t
);
end entity i n v ;
−−
architecture d a t a f l o w of i n v i s
begin
out1 <= not i n 1 ;
end architecture d a t a f l o w ;
−−
31
entity t e s t b e n c h i s −− Test bench o u t e r e n t i t y wrapper .
end entity t e s t b e n c h ;
−−
l i b r a r y work ;
use work . a l l ;
−−
architecture s t r u c t u r a l of t e s t b e n c h i s −− T e s t b e n c h a r c h i t e c t u r e .
s i g n a l b0 , b1 , b2 , b3 , zb , yb , xb , wb , a , b , c , d , f : b i t ;
begin
d1 : entity t e s t v e c t o r port map( b0 , b1 , b2 , b3 ) ;
d2 : entity i n v port map( b0 , wb ) ;
d3 : entity i n v port map( b1 , xb ) ;
d4 : entity i n v port map( b2 , yb ) ;
d5 : entity i n v port map( b3 , zb ) ;
d6 : entity and4 port map( zb , yb , b1 , wb , a ) ;
d7 : entity and4 port map( zb , yb , xb , wb , b ) ;
d8 : entity and3 port map( zb , yb , b0 , c ) ;
d9 : entity and4 port map( b0 , b1 , b2 , b3 , d ) ;
d10 : entity o r 4 port map( a , b , c , d , f ) ;
end architecture s t r u c t u r a l ;
On entry of this code into the Qucs VHDL text editor the text is colour
coded. Unfortunately, the colour coding is lost when printed, or pasted
into a word processor, or a layout package like LaTeX. The structure of the
VHDL listing follows the normal convention for text based VHDL simulation.
All component entity-architecture models must be defined before they are
referenced in other component models. The simulation test bench must be
the last entity-architecture model in the VHDL listing. During the VHDL
compile phase FreeHDL compiles the component entity-architecture models
to the work library16 . These compiled models are then made available to the
simulation test bench through the use of the VHDL use statement inserted
in the listing prior to the testbench architecture statement. Once the VHDL
listing for the simulation has been typed into the Qucs VHDL code editor,
pressing key F2 starts the simulation process. The simulation duration can be
set using the Document Settings in the File dropdown menu (or by pressing
the Ctrl+. keys). Any VHDL syntax errors, or indeed typos, are written to
file and can be viewed by pressing key F5. Obviously if errors are reported
these need to be corrected using the VHDL text editor and the simulation
cycle restarted. A typical TimeList output for editor example 1 is shown in
16
In most VHDL implementations library work is always visible and there is no requirement
to make it visible by using the library and use statements. However, FreeHDL appears to need
these statements at the linking phase otherwise the VHDL compiler fails.
32
Fig. 11.
dtime 0 20n 40n 60n 80n 100n 120n 140n 160n 180n 200n 220n 240n 260n 280n 300n 320n
b0.X
b1.X
b2.X
b3.X
f.X
Figure 11: Sample simulation waveforms for VHDL editor example 1 design.
33
−−
p1 : process (CLOCK ) i s
begin
i f (CLOCK’ e v e n t and CLOCK= ’1 ’) then
p r e s e n t s t a t e <= n e x t s t a t e ;
end i f ;
end process p1 ;
−−
p2 : process (RESET, present state ) is
begin
i f (RESET = ’ 1 ’ ) then n e x t s t a t e <= ”1111 ” ;
end i f ;
case p r e s e n t s t a t e i s
when ”0000 ” => n e x t s t a t e <= ”0001 ” ;
when ”0001 ” => n e x t s t a t e <= ”0010 ” ;
when ”0010 ” => n e x t s t a t e <= ”0011 ” ;
when ”0011 ” => n e x t s t a t e <= ”0100 ” ;
when ”0100 ” => n e x t s t a t e <= ”0101 ” ;
when ”0101 ” => n e x t s t a t e <= ”0110 ” ;
when ”0110 ” => n e x t s t a t e <= ”0111 ” ;
when ”0111 ” => n e x t s t a t e <= ”1000 ” ;
when ”1000 ” => n e x t s t a t e <= ”1001 ” ;
when ”1001 ” => n e x t s t a t e <= ”1010 ” ;
when ”1010 ” => n e x t s t a t e <= ”1011 ” ;
when ”1011 ” => n e x t s t a t e <= ”1100 ” ;
when ”1100 ” => n e x t s t a t e <= ”1101 ” ;
when ”1101 ” => n e x t s t a t e <= ”1110 ” ;
when ”1110 ” => n e x t s t a t e <= ”1111 ” ;
when ”1111 ” => n e x t s t a t e <= ”0000 ” ;
end case ;
B3 <= n e x t s t a t e ( 3 ) ; B2 <= n e x t s t a t e ( 2 ) ;
B1 <= n e x t s t a t e ( 1 ) ; B0 <= n e x t s t a t e ( 0 ) ;
end process p2 ;
end architecture b e h a v i o u r a l ;
−−
l i b r a r y work ;
use work . a l l ;
−−
entity t e s t b e n c h i s
end entity t e s t b e n c h ;
−−
architecture d a t a f l o w of t e s t b e n c h i s
s i g n a l r e s e t , c l k , b0 , b1 , b2 , b3 , zb : b i t ;
34
s i g n a l yb , xb , wb , a , b , c , d , f : b i t ;
begin
p1 : process i s
begin
c l k <= ’ 0 ’ ; wait f o r 10 ns ;
c l k <= ’ 1 ’ ; wait f o r 10 ns ;
end process p1 ;
−−
p2 : process i s
begin
r e s e t <= ’ 1 ’ ; wait f o r 10 ns ;
r e s e t <= ’ 0 ’ ; wait f o r 2000 ns ;
end process p2 ;
−−
d1 : entity t e s t v e c t o r a port map( r e s e t , c l k , b0 , b1 , b2 , b3 ) ;
−−
−− Data f l o w model o f c o m b i n a t i o n a l c i r c u i t
wb <= not b0 ; xb <= not b1 ; yb <= not b2 ; zb <= not b3 ;
a <= (wb and b1 ) and ( yb and zb ) ;
b <= (wb and xb ) and ( yb and zb ) ;
c <= b0 and ( yb and zb ) ;
d <= ( b0 and b1 ) and ( b2 and b3 ) ;
f <= a or b or c or d ;
end architecture d a t a f l o w ;
dtime 0 10n 20n 30n 40n 50n 60n 70n 80n 90n 100n 110n 120n 130n 140n 150n 160n 170n
reset.X
b0.X
b1.X
b2.X
b3.X
f.X
Figure 12: Sample simulation waveforms for VHDL editor example 2 design.
35
the next state data and the transfer of the next state information to the
present state. This approach is necessary because FreeHDL does not allowed
shared variables. Once again in this example only single bit data is passed
via the entity statement to the device under test. The device under test is
represented by a truth table encoded in a process statement. This is not the
most elegant code but it does serve the purpose of demonstrating the use
of different VHDL constructions and data types in Qucs digital simulation.
A typical TimeList plot for VHDL editor example 3 is shown in Fig. 13.
Comparison of the three output plots for the VHDL editor examples indicates
that all the simulation results are very similar with some slight differences in
the start up phase following the RESET pulse changing from logic ’1’ to logic
’0’. This is probably an effect due to the different initialisation sequences for
each of the test vector models.
−− Qucs VHDL e d i t o r example 3
−−
entity t e s t v e c t o r b i s
port ( RESET, CLOCK : in b i t ;
B0 , B1 , B2 , B3 : out b i t
);
end entity t e s t v e c t o r b ;
−−
architecture b e h a v i o u r a l of t e s t v e c t o r b i s
begin
p1 : process (RESET, CLOCK) i s
variable p r e s e n t s t a t e , n e x t s t a t e :
b i t v e c t o r ( 3 downto 0):= ”0000 ” ;
begin
i f (RESET = ’ 1 ’ ) then n e x t s t a t e := ”0000 ” ;
e l s i f (CLOCK’ e v e n t and CLOCK= ’1 ’) then
p r e s e n t s t a t e := n e x t s t a t e ;
case p r e s e n t s t a t e i s
when ”0000 ” => n e x t s t a t e := ”0001 ” ;
when ”0001 ” => n e x t s t a t e := ”0010 ” ;
when ”0010 ” => n e x t s t a t e := ”0011 ” ;
when ”0011 ” => n e x t s t a t e := ”0100 ” ;
when ”0100 ” => n e x t s t a t e := ”0101 ” ;
when ”0101 ” => n e x t s t a t e := ”0110 ” ;
when ”0110 ” => n e x t s t a t e := ”0111 ” ;
when ”0111 ” => n e x t s t a t e := ”1000 ” ;
when ”1000 ” => n e x t s t a t e := ”1001 ” ;
when ”1001 ” => n e x t s t a t e := ”1010 ” ;
when ”1010 ” => n e x t s t a t e := ”1011 ” ;
36
when ”1011 ” => n e x t s t a t e := ”1100 ” ;
when ”1100 ” => n e x t s t a t e := ”1101 ” ;
when ”1101 ” => n e x t s t a t e := ”1110 ” ;
when ”1110 ” => n e x t s t a t e := ”1111 ” ;
when ”1111 ” => n e x t s t a t e := ”0000 ” ;
end case ;
end i f ;
B3 <= n e x t s t a t e ( 3 ) ; B2 <= n e x t s t a t e ( 2 ) ;
B1 <= n e x t s t a t e ( 1 ) ; B0 <= n e x t s t a t e ( 0 ) ;
end process p1 ;
end architecture b e h a v i o u r a l ;
−−
l i b r a r y work ;
use work . a l l ;
−−
entity t e s t b e n c h i s
end entity t e s t b e n c h ;
−−
architecture d a t a f l o w of t e s t b e n c h i s
s i g n a l r e s e t , c l k , b0 , b1 , b2 , b3 , f : bit ;
begin
p1 : process i s
begin
c l k <= ’ 0 ’ ; wait f o r 10 ns ;
c l k <= ’ 1 ’ ; wait f o r 10 ns ;
end process p1 ;
−−
p2 : process i s
begin
r e s e t <= ’ 1 ’ ; wait f o r 10 ns ;
r e s e t <= ’ 0 ’ ; wait f o r 2000 ns ;
end process p2 ;
−−
d1 : entity t e s t v e c t o r b port map( r e s e t , c l k , b0 , b1 , b2 , b3 ) ;
−−
−− B e h a v i o u r a l model o f c o m b i n a t i o n a l c i r c u i t
p3 : process ( b3 , b2 , b1 , b0 ) i s
variable SEL : b i t v e c t o r ( 3 downto 0 ) ;
begin
SEL := b3&b2&b1&b0 ;
i f (SEL = ”0010 ”) then f <= ’ 1 ’ ;
e l s i f (SEL = ”0000 ”) then f <= ’ 1 ’ ;
e l s i f (SEL = ”1111 ”) then f <= ’ 1 ’ ;
37
e l s i f (SEL = ”0001 ”) then f <= ’ 1 ’ ;
e l s i f (SEL = ”0011 ”) then f <= ’ 1 ’ ;
e l s e f <= ’ 0 ’ ;
end i f ;
end process p3 ;
end architecture d a t a f l o w ;
dtime 0 10n 20n 30n 40n 50n 60n 70n 80n 90n 100n 110n 120n 130n 140n 150n 160n 170n
reset.X
b0.X
b1.X
b2.X
b3.X
f.X
Figure 13: Sample simulation waveforms for VHDL editor example 3 design.
38
Shown in Table 4 is the VHDL entity-architecture model listing for a 4 bit
binary pattern generator. The VHDL code is identical to the test vector code
introduced in the third VHDL editor example. After entering the VHDL
entity-architecture model code using the Qucs VHDL editor the finished
text is saved in a file with a suitable name and file extension vhdl. Qucs
then lists the model under the VHDL project category. Simply clicking on a
model name in the VHDL category, with the left hand mouse button, then
moving the mouse pointer to a suitable position on a schematic, causes Qucs
to move a symbol that represents the model onto the schematic drawing
sheet. Placement of the symbol at the position located by the mouse pointer
is achieved by clicking the left hand mouse button. The procedure is identical
to that used to select and place the Qucs predefined symbols on a schematic
drawing. Qucs automatically generates a rectangular symbol with a name
called VHDL that has the same number of pins as the port statement listed
in the VHDL model entity statement. Each of the pins is given a name
that corresponds to a name in the entity statement. Qucs fixes the order
of the pins on the generated symbol. It appears that it is not possible to
edit this symbol. However, subcircuit in, out or inout port symbols can
be attached to symbol VHDL and a user edited symbol generated. Fig. 14
shows the Qucs generated VHDL symbol with attached ports for the model
listed in Table 4. The edited symbol for the 4 bit binary pattern generator
is illustrated in Fig. 15. Notice that in Fig. 15 the order of the pins has
been changed to reflect the natural order for a device with it’s input pins
on the left and output pins on the right. VHDL model symbols can also
be generated by placing the VHDL file component, this is located in the
digital components viewlist, on a schematic. On editing the VHDL file name
property of this device to the name of a VHDL entity-architecture model file,
Qucs automatically generates a VHDL symbol. Defining your own symbol
then proceeds in a similar fashion to the way described above.
39
entity p a t g e n 4 b i t i s
port ( RESET, CLOCK : in b i t ;
B0 , B1 , B2 , B3 : out b i t
);
end entity p a t g e n 4 b i t ;
−−
architecture b e h a v i o u r a l of p a t g e n 4 b i t i s
begin
p1 : process (RESET, CLOCK) i s
variable p r e s e n t s t a t e , n e x t s t a t e :
b i t v e c t o r ( 3 downto 0):= ”0000 ” ;
begin
i f (RESET = ’ 1 ’ ) then n e x t s t a t e := ”0000 ” ;
e l s i f (CLOCK’ e v e n t and CLOCK= ’1 ’) then
p r e s e n t s t a t e := n e x t s t a t e ;
case p r e s e n t s t a t e i s
when ”0000 ” => n e x t s t a t e := ”0001 ” ;
when ”0001 ” => n e x t s t a t e := ”0010 ” ;
when ”0010 ” => n e x t s t a t e := ”0011 ” ;
when ”0011 ” => n e x t s t a t e := ”0100 ” ;
when ”0100 ” => n e x t s t a t e := ”0101 ” ;
when ”0101 ” => n e x t s t a t e := ”0110 ” ;
when ”0110 ” => n e x t s t a t e := ”0111 ” ;
when ”0111 ” => n e x t s t a t e := ”1000 ” ;
when ”1000 ” => n e x t s t a t e := ”1001 ” ;
when ”1001 ” => n e x t s t a t e := ”1010 ” ;
when ”1010 ” => n e x t s t a t e := ”1011 ” ;
when ”1011 ” => n e x t s t a t e := ”1100 ” ;
when ”1100 ” => n e x t s t a t e := ”1101 ” ;
when ”1101 ” => n e x t s t a t e := ”1110 ” ;
when ”1110 ” => n e x t s t a t e := ”1111 ” ;
when ”1111 ” => n e x t s t a t e := ”0000 ” ;
end case ;
end i f ;
B3 <= n e x t s t a t e ( 3 ) ; B2 <= n e x t s t a t e ( 2 ) ;
B1 <= n e x t s t a t e ( 1 ) ; B0 <= n e x t s t a t e ( 0 ) ;
end process p1 ;
end architecture b e h a v i o u r a l ;
40
CLOCK
Num=2
RESET CLOCK
RESET B1
Num=1 Num=4
B0 B1
vhdl
B0 B3
Num=3 Num=6
B2 B3
B2
Num=5 X1
Figure 14: Qucs generated VHDL symbol with subcircuit ports for test pattern
generator.
SUB
patgen File=name
4bit
RESET R B0 B0
B1 B1
CLOCK B2 B2
B3 B3
−− F u l l adder − 1 b i t
entity f u l l a d d e r i s
port ( a , b , c i n : in b i t ;
sum , c o u t : out b i t
);
end entity f u l l a d d e r ;
−−
architecture d a t a f l o w of f u l l a d d e r i s
begin
sum <= ( a xor b ) xor c i n ;
c o u t <= ( a and b ) or ( a and c i n ) or ( b and c i n ) ;
end architecture d a t a f l o w ;
41
b
a b
a
sum
cin sum
vhdl
cin
cout
cout
X1
Figure 16: Qucs generated VHDL symbol with subcircuit ports for one bit full
adder.
42
SUB
File=name
a sum
b
CO cout
cin CI
Figure 18 shows the schematic for a simple 4 bit ripple adder. The corre-
sponding user defined symbol for the 4 bit full adder is given in Fig. 19.
SUB1
sum0
a0
CO
b0 CI
cin
SUB2
sum1
a1
CO
b1 CI
SUB3
sum2
a3
CO
b2 CI
SUB4
sum3
a4
CO
b3 CI cout
43
a0 0 sum0
a1
a3 } a { sum1
sum2
a4 3 sum3
b0 0
b1 cout
b2 }b CO
b3 3
cin CI
SUB
File=name
b3 b2 b1 b0
a3 a2 a1 a0
a0b3 a0b2 a0b1 a0b0
a1b3 a1b2 a1b1 a1b0
a2b3 a2b2 a2b1 a2b0
a3b3 a3b2 a3b1 a3b0
r7 r6 r5 r4 r3 r2 r1 r0
Table 6: Product table for a 4 bit by 4 bit combinational multiplier.
The example chosen for this purpose is a 4 bit by 4 bit combinational digital
multiplier. Both the 4 bit pattern generator and the 4 bit full adder outlined in
the last section form part of the central core of the 4 bit multiplier design and
it’s associated testbench. Table 6 shows the multiplication product table for a 4
bit by 4 bit combinational binary multiplier. Inputs to the device are binary bits
a3 a2 a1 a0 and b3 b2 b1 b0. The 4 by 4 multiplier device requires 16 and gates
(to generate the multiplier product terms), three four bit full adders (to sum the
output r terms) and two 4 bit pattern generators to test the 256 possible input
states. The multiplier output is represented in Table 6 by r7 r6 r5 r4 r3 r2 r1 and
r0. The circuit schematic for the 4 bit by 4 bit multiplier and test bench are given
in Fig. 20.
The VHDL code for this example is presented in the following listing. This listing
44
was generated by Qucs20 . A small section of the TimeList waveform plot for the
digital multiplier is shown in Fig. 21. At 1.74 micro seconds input a is ”0101”, input
b is ”0111” and the output r is ”00100011” which is 35 in decimal. Taking a few
random checks of the simulation results indicates that the 4 bit by 4 bit multiplier
design works correctly. Notice that the VHDL code generated by Qucs for the 4
bit multiplier does not contain any propagation delay timing data. This could be
added to the and gates, if required. However, at this stage in the development of
Qucs digital simulation passing timing data, and other parameters, from device
symbols generated from VHDL models has not been implemented yet. The use
of VHDL generics is an obvious way this could be done. Generics are allowed, of
course, in text based VHDL simulations.
20
Some readers will have noticed that the naming scheme for internal signal nets is different
in the multiplier VHDL listing when compared to the VHDL listings in the first version of these
notes. Towards the end of the 0.0.9 development phase the naming convention employed by Qucs
was changed to give a more flexible structure.
45
Y1
CLOCK
digital
1 simulation
R CLOCK
Digi1
SUB3 SUB1
Type=TimeList
R time=5000 ns
R
R
patgen
patgen
4bit
4bit
SUB5
0
B3
B2
B1
B0
B3
B2
B1
B0
A3 A2 A1 A0 B3 B2 B1 B0
R0
&
Y2 & R1
0
Y3 &
}a {
Y4 &
3
Y5 & 0
Y6 & }b CO
3
Y7 &
CI
R2
Y8 &
SUB4 0
Y9 & }a {
3
&
Y10
0
&
Y11
}b CO R3
R4
0
&
Y12 3
}a { R5
R6
CI
&
Y13
3
& SUB6 0 R7
Y14
&
Y15 }b CO
3
&
Y16
CI
Y17
SUB7
File=full_adder_4 bit.sch
46
−− Qucs 0 . 0 . 9
−− /mnt/ hda2 / v h d l c o m p l i b p r j / m u l t i p l i e r 4 b x 4 b i t . s c h
entity p a t g e n 4 b i t i s
port ( RESET, CLOCK : in b i t ;
B0 , B1 , B2 , B3 : out b i t
);
end entity p a t g e n 4 b i t ;
−−
architecture b e h a v i o u r a l of p a t g e n 4 b i t i s
begin
p1 : process (RESET, CLOCK) i s
variable p r e s e n t s t a t e , n e x t s t a t e :
b i t v e c t o r ( 3 downto 0 ) := ”0000 ” ;
begin
i f (RESET = ’ 1 ’ ) then n e x t s t a t e := ”0000 ” ;
e l s i f (CLOCK’ e v e n t and CLOCK= ’1 ’) then
p r e s e n t s t a t e := n e x t s t a t e ;
case p r e s e n t s t a t e i s
when ”0000 ” => n e x t s t a t e := ”0001 ” ;
when ”0001 ” => n e x t s t a t e := ”0010 ” ;
when ”0010 ” => n e x t s t a t e := ”0011 ” ;
when ”0011 ” => n e x t s t a t e := ”0100 ” ;
when ”0100 ” => n e x t s t a t e := ”0101 ” ;
when ”0101 ” => n e x t s t a t e := ”0110 ” ;
when ”0110 ” => n e x t s t a t e := ”0111 ” ;
when ”0111 ” => n e x t s t a t e := ”1000 ” ;
when ”1000 ” => n e x t s t a t e := ”1001 ” ;
when ”1001 ” => n e x t s t a t e := ”1010 ” ;
when ”1010 ” => n e x t s t a t e := ”1011 ” ;
when ”1011 ” => n e x t s t a t e := ”1100 ” ;
when ”1100 ” => n e x t s t a t e := ”1101 ” ;
when ”1101 ” => n e x t s t a t e := ”1110 ” ;
when ”1110 ” => n e x t s t a t e := ”1111 ” ;
when ”1111 ” => n e x t s t a t e := ”0000 ” ;
end case ;
end i f ;
B3 <= n e x t s t a t e ( 3 ) ; B2 <= n e x t s t a t e ( 2 ) ;
B1 <= n e x t s t a t e ( 1 ) ; B0 <= n e x t s t a t e ( 0 ) ;
end process p1 ;
end architecture b e h a v i o u r a l ;
entity S u b p a t g e n 4 b i t i s
47
port ( n e t n e t 0 : in b i t ;
n e t n e t 5 : in b i t ;
n e t o u t n e t n e t 1 : out b i t ;
n e t o u t n e t n e t 3 : out b i t ;
n e t o u t n e t n e t 2 : out b i t ;
n e t o u t n e t n e t 4 : out b i t ) ;
end entity ;
use work . a l l ;
architecture A r c h S u b p a t g e n 4 b i t of S u b p a t g e n 4 b i t i s
signal net net1 ,
net net2 ,
net net3 ,
net net4 : bit ;
begin
n e t o u t n e t n e t 1 <= n e t n e t 1 or ’ 0 ’ ;
n e t o u t n e t n e t 2 <= n e t n e t 2 or ’ 0 ’ ;
n e t o u t n e t n e t 3 <= n e t n e t 3 or ’ 0 ’ ;
n e t o u t n e t n e t 4 <= n e t n e t 4 or ’ 0 ’ ;
X1 : entity p a t g e n 4 b i t port map ( n e t n e t 0 , n e t n e t 5 ,
net net1 , net net3 , net net2 , net net4 ) ;
end architecture ;
−− l o g i c z e r o . v h d l
entity l o g i c z e r o i s
port ( Y : out b i t
);
end entity l o g i c z e r o ;
−−
architecture d a t a f l o w of l o g i c z e r o i s
begin
Y <= ’ 0 ’ ;
end architecture d a t a f l o w ;
entity S u b l o g i c z e r o i s
port ( n e t o u t n e t Y : out b i t ) ;
end entity ;
use work . a l l ;
architecture A r c h S u b l o g i c z e r o of S u b l o g i c z e r o i s
s i g n a l netY : b i t ;
begin
X1 : entity l o g i c z e r o port map ( netY ) ;
48
n e t o u t n e t Y <= netY or ’ 0 ’ ;
end architecture ;
−− F u l l adder − 1 b i t
entity f u l l a d d e r i s
port ( a , b , c i n : in b i t ;
sum , c o u t : out b i t
);
end entity f u l l a d d e r ;
−−
architecture d a t a f l o w of f u l l a d d e r i s
begin
sum <= ( a xor b ) xor c i n ;
c o u t <= ( a and b ) or ( a and c i n ) or ( b and c i n ) ;
end architecture d a t a f l o w ;
entity S u b f u l l a d d e r 1 b i t i s
port ( n e t n e t 0 : in b i t ;
n e t n e t 1 : in b i t ;
n e t n e t 2 : in b i t ;
n e t o u t n e t n e t 3 : out b i t ;
n e t o u t n e t n e t 4 : out b i t ) ;
end entity ;
use work . a l l ;
architecture A r c h S u b f u l l a d d e r 1 b i t of S u b f u l l a d d e r 1 b i t i s
signal net net3 ,
net net4 : bit ;
begin
X1 : entity f u l l a d d e r port map ( n e t n e t 0 , n e t n e t 1 ,
net net2 , net net3 , net net4 ) ;
n e t o u t n e t n e t 3 <= n e t n e t 3 or ’ 0 ’ ;
n e t o u t n e t n e t 4 <= n e t n e t 4 or ’ 0 ’ ;
end architecture ;
49
n e t n e t 5 : in b i t ;
n e t n e t 6 : in b i t ;
n e t n e t 1 3 : in b i t ;
n e t n e t 7 : in b i t ;
n e t o u t n e t n e t 8 : out b i t ;
n e t o u t n e t n e t 9 : out b i t ;
n e t o u t n e t n e t 1 0 : out b i t ;
n e t o u t n e t n e t 1 1 : out b i t ;
n e t o u t n e t n e t 1 2 : out b i t ) ;
end entity ;
use work . a l l ;
architecture A r c h S u b f u l l a d d e r 4 b i t of S u b f u l l a d d e r 4 b i t i s
signal net net14 ,
net net15 ,
net net16 ,
net net8 ,
net net9 ,
net net10 ,
net net11 ,
net net12 : bit ;
begin
n e t o u t n e t n e t 8 <= n e t n e t 8 or ’ 0 ’ ;
n e t o u t n e t n e t 9 <= n e t n e t 9 or ’ 0 ’ ;
n e t o u t n e t n e t 1 0 <= n e t n e t 1 0 or ’ 0 ’ ;
n e t o u t n e t n e t 1 1 <= n e t n e t 1 1 or ’ 0 ’ ;
n e t o u t n e t n e t 1 2 <= n e t n e t 1 2 or ’ 0 ’ ;
SUB4 : entity S u b f u l l a d d e r 1 b i t port map ( n e t n e t 3 , n e t n e t 1 3 ,
net net14 , net net11 , net net12 ) ;
SUB3 : entity S u b f u l l a d d e r 1 b i t port map ( n e t n e t 2 , n e t n e t 6 ,
net net15 , net net10 , net net14 ) ;
SUB2 : entity S u b f u l l a d d e r 1 b i t port map ( n e t n e t 1 , n e t n e t 5 ,
net net16 , net net9 , net net15 ) ;
SUB1 : entity S u b f u l l a d d e r 1 b i t port map ( n e t n e t 0 , n e t n e t 4 ,
net net7 , net net8 , net net16 ) ;
end architecture ;
entity TestBench i s
end entity ;
use work . a l l ;
50
netR3 , netR4 , netR5 , netR6 , netR7 , netCLOCK ,
net net0 , net net1 , net net2 , net net3 , net net4 ,
net net5 , net net6 , net net7 , net net8 , net net9 ,
net net10 , net net11 , net net12 , net net13 , net net14 ,
net net15 , net net16 , net net17 , net net18 , net net19 ,
net net20 , net net21 , net net22 , net net23 ,
net net24 : bit ;
begin
SUB3 : entity S u b p a t g e n 4 b i t port map ( netR , n e t n e t 0 ,
netA0 , netA1 , netA2 , netA3 ) ;
SUB1 : entity S u b p a t g e n 4 b i t port map ( netR , netCLOCK ,
netB0 , netB1 , netB2 , netB3 ) ;
R: process
begin
netR <= ’ 1 ’ ; wait f o r 10 ns ;
netR <= ’ 0 ’ ; wait f o r 2000 ns ;
end process ;
CLOCK: process
begin
netCLOCK <= ’ 0 ’ ; wait f o r 10 ns ;
netCLOCK <= ’ 1 ’ ; wait f o r 10 ns ;
end process ;
51
net net15 , net net16 ) ;
SUB6 : entity S u b f u l l a d d e r 4 b i t port map ( n e t n e t 1 3 , n e t n e t 1 4 ,
net net15 , net net16 , net net9 , net net10 , net net11 ,
n e t n e t 1 2 , n e t n e t 4 , netR2 , n e t n e t 1 7 , n e t n e t 1 8 ,
net net19 , net net20 ) ;
n e t n e t 2 1 <= netA3 and netB0 ;
n e t n e t 2 2 <= netA3 and netB1 ;
n e t n e t 2 3 <= netA3 and netB2 ;
n e t n e t 2 4 <= netA3 and netB3 ;
SUB7 : entity S u b f u l l a d d e r 4 b i t port map ( n e t n e t 1 7 , n e t n e t 1 8 ,
net net19 , net net20 , net net21 , net net22 ,
n e t n e t 2 3 , n e t n e t 2 4 , n e t n e t 4 , netR3 , netR4 ,
netR5 , netR6 , netR7 ) ;
end architecture ;
dtime 1.67u 1.68u 1.69u 1.7u 1.71u 1.72u 1.73u 1.74u 1.75u 1.76u 1.77u 1.78u 1.79u
clock.X
a0.X
a1.X
a2.X
a3.X
b0.X
b1.X
b2.X
b3.X
r0.X
r1.X
r2.X
r3.X
r4.X
r5.X
r6.X
r7.X
Figure 21: A section of the 4 bit by 4 bit combinational digital multiplier TimeList
output waveforms.
52
Web site roughly three months ago. During this period a number of significant, and
very critical, extensions have been implemented. Previous releases concentrated
on establishing a fundamental base for digital circuit simulation using the VHDL
language. The primary vehicle for representing circuit signals being the VHDL bit
and bit-vector signal types. The next release of Qucs (version 0.0.10) and FreeHDL
(version 0.0.3) extends the allowed signal types to include IEEE std_logic_1164
nine level logic, integers, and reals. Readers will appreciate that these changes are
the result of a great deal of work by the Qucs team and must be considered as very
much work in progress because not all the features offered by the FreeHDL imple-
mentation of the VHDL language are currently available via the Qucs schematic
capture and VHDL text file simulation routes. Although a significant amount of
testing has taken place it is likely that software bugs will come to light as more
Qucs users try the new features - if you find a bug please report it by posting a
note on the Qucs Web site. Adding new signal types to Qucs digital simulation
affects all sections of the simulation route from schematic capture to plotting and
tabulating input and output signals. Hence, although it may seem the wrong way
round, the place to first implement the necessary changes to accommodate the
new signal types is at the simulation results reporting stages of the Qucs package.
In release 0.0.10 no attempt has been made to add the new signal types to the
schematic capture part of the Qucs package.21 Recent work on the digital sections
of the Qucs package has concentrated on (1) improvements to VHDL language
entry using the Qucs colour coded VHDL text editor22 , (2) modifications to Free-
HDL which allow a cleaner interface between Qucs and FreeHDL, (3) upgrades to
the data conversion of simulation results from the FreeHDL value change dump
format to the native Qucs format, and (4) major changes to the results reporting
routines that are accessed from the Qucs diagrams icon dialogue. A detailed list of
the software changes and bug fixes can be found in the Qucs and FreeHDL change
log files.
53
of the process employed by Qucs and FreeHDL is needed if users of the software are
to be able to write meaningful VHDL code and simulate it using the two packages.
VHDL code is either generated from a schematic diagram automatically by Qucs
or entered using the Qucs VHDL text editor. The use of the schematic entry route
was described in update one of these tutorial notes. However, a number of readers
will probably have spotted that included in the VHDL code generated by Qucs
are references to VHDL libraries. The VHDL language uses libraries to provide
features that are not specified in the basic language definition but are commonly
used by all language processing systems; two such libraries are STD and IEEE.
When simulating digital circuits a basic knowledge of the structure of a simulation
task and how these employ VHDL libraries is essential. This implies that users of
the Qucs/FreeHDL software must appreciate how the system compiles and simu-
lates a VHDL circuit simulation task. Once the VHDL simulation code has been
entered via the VHDL text editor clicking the Qucs simulation button runs shell
script qucsdigi performing the sequence shown in Fig. 2223 . Program freeehdl-v2cc
converts VHDL code into C++ functions. These are then compiled along with
a main C++ function. The next stage in the sequence links the compiled object
code with the object code from any references to items in the predefined VHDL
libraries to produce an executable digital simulation program. This is then run by
Qucs outputting a set of simulation results in value change dump (VCD) format24 .
Finally a program called qucsconv converts the VCD simulation results into the
Qucs native data format ready for post processing as graphical or tabular diagrams
by Qucs.
23
For the FreeHDL package to operate correctly the directory where the software is installed
must be included in the shell PATH from which Qucs is launched.
24
The value change dump language was originally designed as a simulation waveform inter-
change format for Verilog HDL. The specification of the VCD format can be found at http://www-
ee.eng.hawaii.edu/ msmith/ASICs/HTML/Verilog/LRM/HTML/15/ch15.2.htm
54
VHDL source text
file_name.vhdl OR
file_name.vhd
FreeHDL V2CC
Running C++ VHDL -> C++
conversion.... conversion
}
file_name.cc
file_name.o
FreeHDL Compile
Compiling main... C++ main function
file_name_main_.o
Linking....
file_name.vcd
Figure 22: Detailed flow diagram showing VHDL code compilation and simulation
results processing.
55
VHDL predefined packages and libraries.
All VHDL language processing systems provide a predefined VHDL package called
standard. This package defines many of the fundamental VHDL data types, for
example bit, character, integer and real. The predefined types, subtypes and
other functions in the package standard are stored in a library called STD. The
FreeHDL version of library STD includes an additional VHDL package called textio
which is used to input and output signal data from and to files. A second library
called IEEE defines (1) multivalued logic signals defined by nine different encoding
values, making it possible to model digital circuits that are composed from different
technology components, (2) logic signal subtypes and (3) an extensive range of
useful functions, procedures and overloaded operators. The FreeHDL version of
the IEEE library consists of the following packages:
1. std_logic_1164
2. numeric_bit
3. math_real
4. numeric_std
5. std_logic_arith
6. std_logic_unsigned
7. vital_timing
One other library is always defined by VHDL code processing systems namely the
work library. This library holds user compiled VHDL entity/architecture design
units.
56
VHDL data types, functions and operators in package standard are always visible
to VHDL test bench code and reference to their use need not be added explicitly.
However, if the test bench entity-architecture uses data types or other items de-
fined in other libraries, for example the std_logic type in the IEEE library, then
reference to them needs to be added before each entity-architecture pair where they
are used. Libraries are referenced using the VHDL library and use statements. An
example showing how these statements are employed is outlined in the following
VHDL code segment:
library i e e e ;
use i e e e . s t d l o g i c 1 1 6 4 . a l l ;
−−
entity t e s t b e n c h i s
−− e n t i t y body s t a t e m e n t s
end entity t e s t b e n c h ;
−−
architecture b e h a v i o u r a l of t e s t b e n c h i s
−− a r c h i t e c t u r e body s t a t e m e n t s
end architecture b e h a v i o u r a l ;
Here the VHDL code word all signifies that all items in a specific library are to be
made available for use in the following entity/architecture pair; testbench in the
above example. If more than one library is to be used then a library/use statement
is needed for each library reference. Most complete VHDL circuit simulation pro-
grams consist of more than one entity/architecture pair. In such cases the circuit
test bench, with its signal test vectors, must be the last entry in the program. An
example of a more complex VHDL program structure is
library i e e e ;
use i e e e . s t d l o g i c 1 1 6 4 . a l l ;
−−
entity comp1 i s
−− e n t i t y body s t a t e m e n t s
end entity comp1 ;
−−
architecture b e h a v i o u r a l of comp1 i s
−− a r c h i t e c t u r e body s t a t e m e n t s
end architecture b e h a v i o u r a l ;
−−
library i e e e ;
use i e e e . s t d l o g i c 1 1 6 4 . a l l ;
−−
entity comp2 i s
−− e n t i t y body s t a t e m e n t s
57
end entity comp2 ;
−−
architecture b e h a v i o u r a l of comp2 i s
−− a r c h i t e c t u r e body s t a t e m e n t s
end architecture b e h a v i o u r a l ;
−−
library i e e e ;
use i e e e . s t d l o g i c 1 1 6 4 . a l l ;
−−
use work . a l l ;
−−
entity t e s t b e n c h i s
−− e n t i t y body s t a t e m e n t s
end entity t e s t b e n c h ;
−−
architecture b e h a v i o u r a l of t e s t b e n c h i s
−− a r c h i t e c t u r e body s t a t e m e n t s
end architecture b e h a v i o u r a l ;
During the conversion of VHDL code to a machine code simulation program each
entity/architecture pair, prior to the final test bench entry, is compiled as a sep-
arate design unit and stored in the work library26 . Compiled design units held in
the work library can be referenced in other entity/architecture models provided
the VHDL statement use work.all; 27 is inserted in the VHDL simulation code prior
to each entity/architecture statement where they are referenced.
26
The testbench entity/architecture pair is also, of course, compiled but this design unit is the
one that is run as the executable simulation program.
27
References to individual items are also allowed by inserting, for example, use.work.comb1;
use.work.comb2; in the VHDL code.
58
VHDL data types.
VHDL data
types
The chart shown in Fig. 23 indicates the different data types that are available
in the VHDL language. FreeHDL implements all these data types. In practical
circuit simulation the different VHDL data types are normally used to specify
(1) signals, (2) variables and (3) constants28 . During simulation Qucs/FreeHDL
automatically stores the values of integer, real and enumerated bit signals as simu-
lation time progresses. Furthermore, bit_vector and IEEE signal types including
std_logic_vector are also stored. Signals of these types are then available for
plotting and tabulation using the Timing, Truth table, Tabular and Cartesian out-
put diagrams. Selected elements in user defined composite signals, those that are
stored in arrays for example29 , can be assigned to the basic signal types then dis-
played.30 . An example of how this is done is given in later sections of these update
tutorial notes. Note - the values of variables and constants are not recorded during
simulation.
28
Type file is of course different in that it is used to store either test vectors, component data
such as ROM contents and output simulation results.
29
Please note that signal types based on the composite type record will probably cause the
Qucs simulation cycle to fail - work on this data type has been added to the to-do list.
30
Qucs/FreeHDL also automatically collects waveform data for composite signals based on
arrays of bit and IEEE signal types. However, in the case of large arrays care is needed when
plotting or tabulating these directly because the entire contents of an array is output each time
a signal is displayed.
59
An example VHDL simulation employing integer signals.
The following VHDL code demonstrates how the integer data type can be used
to represent signals. In this example signals A, B change state on the rising edge
of clock clk. The code tests the addition of integer signals and constants using
arithmetic operators defined in library STD.31 The results from this simulation
are shown in Fig. 24.
−− A v e r y b a s i c t e s t o f d a t a t y p e i n t e g e r .
entity t e s t b e n c h i s
end entity t e s t b e n c h ;
−−
architecture b e h a v i o u r a l of t e s t b e n c h i s
s i g n a l A, B, C : i n t e g e r := 0 ;
signal c l k : b i t ;
begin
p0 : process i s −− Generate c l o c k s i g n a l .
begin
c l k <= ’ 0 ’ ; wait f o r 10 ns ;
c l k <= ’ 1 ’ ; wait f o r 10 ns ;
end process p0 ;
−−
p1 : process ( c l k ) i s
begin
i f ( c l k ’ e v e n t and c l k = ’1 ’) then
A <= A + 1 ;
B <= B + 2 ;
end i f ;
end process p1 ;
C <= A + B ;
end architecture b e h a v i o u r a l ;
dtime 0 10n 20n 30n 40n 50n 60n 70n 80n 90n 100n
clk.X
a.R 0 1 1 2 2 3 3 4 4 5
b.R 0 2 2 4 4 6 6 8 8 10
c.R 0 3 3 6 6 9 9 12 12 15
Figure 24: Output results for a simple test bench example employing integer sig-
nals.
31
The specification for the FreeHDL library STD can be found in text file freehdl-
0.0.3/std/standard.vhdl.
60
Multivalued logic.
Although signal types bit and bit-vector are widely employed when simulating dig-
ital systems one of their great weaknesses is the fact that it is difficult to represent
signal bus systems simply using only logic ’0’ and logic ’1’ signal encoding. More-
over, circuits where bus signal contention occurs often result in simulation failure.
The IEEE std_logic_1164 package overcomes this limitation through the intro-
duction of a multivalued logic system which defines nine different logic values to
represent signal types and signal strengths. Not only is the bus contention problem
solved through logic resolving functions but the multivalued logic system allows
devices constructed from different manufacturing technologies to be simulated at
the same time, ensuring that the simulation process mirrors real circuit design
practices. The next two simulation examples introduce the nine value logic sys-
tem and demonstrate it’s use in the design of digital bus systems. Signals of type
real are also introduced to show their representation by Qucs. Listed below is the
VHDL code for a basic simulation which generates a set of IEEE std_logic, inte-
ger and real signals. Figure 25 illustrates how the Qucs Timing diagram displays
different signal types. A section of tabulated results are also given in Fig. 26.
library i e e e ;
use i e e e . s t d l o g i c 1 1 6 4 . a l l ;
−−
entity t e s t b e n c h i s
end entity t e s t b e n c h ;
−−
architecture b e h a v i o u r a l of t e s t b e n c h i s
signal c l k : b i t ;
s i g n a l bv1 : b i t v e c t o r ( 8 downto 0 ) ;
s i g n a l s t d l 1 : s t d l o g i c v e c t o r ( 8 downto 0 ) ;
s i g n a l INT1 : i n t e g e r := 0 ;
s i g n a l INT2 : i n t e g e r := 9 9 ;
s i g n a l R1 : r e a l := 0 . 3 3 ;
s i g n a l R2 : r e a l := 9 9 . 0 ;
s i g n a l R3 : r e a l := 0 . 0 ;
s i g n a l R4 : r e a l := 0 . 0 ;
begin
p0 : process i s
begin
c l k <= ’ 0 ’ ; wait f o r 10 ns ;
c l k <= ’ 1 ’ ; wait f o r 10 ns ;
end process p0 ;
−−
61
p1 : process ( c l k ) i s
variable v1 : i n t e g e r := 0 ;
begin
i f ( c l k ’ e v e n t and c l k = ’ 1 ’ ) then
v1 := v1 +1;
case v1 i s
when 1 => bv1 <= ”000000000 ” ; stdl1 <= ”000000000 ” ;
when 2 => bv1 <= ”000000001 ” ; stdl1 <= ”000000001 ” ;
when 3 => bv1 <= ”000000011 ” ; stdl1 <= ”00000001X” ;
when 4 => bv1 <= ”000000111 ” ; stdl1 <= ”0000001XZ” ;
when 5 => bv1 <= ”000001111 ” ; stdl1 <= ”000001XZU” ;
when 6 => bv1 <= ”000011111 ” ; stdl1 <= ”00001XZUW” ;
when 7 => bv1 <= ”000111111 ” ; stdl1 <= ”0001XZUWL” ;
when 8 => bv1 <= ”001111111 ” ; stdl1 <= ”001XZUWLH” ;
when 9 => bv1 <= ”111111111 ” ; stdl1 <= ”01XZUWLH−” ;
when others => v1 := 0 ;
end case ;
end i f ;
end process p1 ;
p3 : process ( c l k ) i s
begin
i f ( c l k ’ e v e n t and c l k = ’1 ’) then
INT1 <= INT1 + 1 ;
INT2 <= INT2 −20;
end i f ;
−−
i f ( INT1 >= 9 ) then
INT1 <= 0 ;
INT2 <= 9 9 ;
end i f ;
end process p3 ;
−−
p4 : process ( c l k ) i s
Variable V2 : r e a l ;
begin
i f ( c l k ’ e v e n t and c l k = ’1 ’) then
R1 <= R1 + 1 . 0 ;
R2 <= R2 −20.0;
R3 <= R1∗R2 ;
R4 <= R2/ (R1 + 0 . 0 0 0 1 ) ;
end i f ;
−−
i f (R1 >= 2 0 . 0 ) then
62
R1 <= 0 . 0 ;
R2 <= 9 9 . 0 ;
end i f ;
end process p4 ;
end architecture b e h a v i o u r a l ;
clk.X
r1.R 0.33 1.33 1.33 2.33 2.33 3.33 3.33 4.33
r2.R 99 79 79 59 59 39 39 19
r3.R 0 32.67 32.67 105.07 105.07 137.47 137.47 129.87
r4.R 0 299.909 299.909 59.394 59.394 25.3208 25.3208 11.7114
stdl1.X XXXXXXXXX 000000000 000000000 000000001 000000001 00000001X 00000001X 0000001XZ
int1.R 0 1 1 2 2 3 3 4
int2.R 99 79 79 59 59 39 39 19
bv1.X 000000000 000000000 000000000 000000001 000000001 000000011 000000011 000000111
clk.X
r1.R 4.33 4.33 5.33 5.33 6.33 6.33 7.33 7.33
r2.R 19 19 1 1 21 21 41 41
r3.R 129.87 129.87 82.27 82.27 5.33 5.33 132.93 132.93
r4.R 11.7114 11.7114 4.38789 4.38789 0.187614 0.187614 3.31748 3.31748
stdl1.X 0000001XZ 0000001XZ 000001XZX 000001XZX 00001XZX0 00001XZX0 0001XZX00 0001XZX00
int1.R 4 4 5 5 6 6 7 7
int2.R 19 19 1 1 21 21 41 41
bv1.X 000000111 000000111 000001111 000001111 000011111 000011111 000111111 000111111
The VCD waveform interchange standard encodes digital signals as four different
logic levels. These are ’0’, ’1’, ’Z’ (high impedance) and ’X’ (unknown). Table 7
lists how the nine ieee.std_logic signal levels are represented using the VCD
format. Until the VCD standard is revised the Qucs/FreeHDL package is restricted
to displaying simulation output data using the basic ’0’, ’1’, ’Z’ and ’X’ signal en-
coding. The next example shows how the IEEE std_logic signal type can be used
to simulate bus logic. The demonstration has been kept simple in order to keep
the VHDL code short. The code fragment simulates two tri-state buffers which
63
VHDL signal levels VCD
’0’ Forcing logic 0 ’0’
’1’ Forcing logic 1 ’1’
’X’ Forcing unknown ’X’
’Z’ High impedance ’Z’
’U’ Uninitialised ’X’
’W’ Weak unknown ’0’
’L’ Weak logic 0 ’0’
’H” Weak logic 1 ’1’
’-’ Don’t care ’X’
pass their outputs to bus drivers who’s outputs connect on a common signal bus.
The bus drivers ensure that the outputs from the tri-state buffers are kept sepa-
rate before combining onto the common bus line. This allows the output signals
from the tri-state buffers and the combined signal to be plotted separately. The
resulting waveforms clearly show the std_logic resolution function in operation,
see Fig. 27 . Note the effect of the 7 ns delay on the plotted waveforms and the
use of the VHDL generic statement to set the invert device delay value.
−− Demonstration o f a s i m p l e bus s t r u c t u r e u s i n g
−− t h e IEEE s t d l o g i c d a t a t y p e .
library i e e e ;
use i e e e . s t d l o g i c 1 1 6 4 . a l l ;
−−
entity buf i s
generic ( d e l a y : time := 0 ns ) ;
port ( in1 , c o n t r o l : in s t d l o g i c ;
out1 : out s t d l o g i c
);
end entity buf ;
architecture b e h a v i o u r a l of buf i s
begin
p0 : process ( in1 , c o n t r o l ) i s
begin
i f ( c o n t r o l = ’ 1 ’ ) then out1 <= i n 1 a f t e r d e l a y ;
e l s e out1 <= ’ Z ’ ;
end i f ;
end process p0 ;
end architecture b e h a v i o u r a l ;
64
−−
library i e e e ;
use i e e e . s t d l o g i c 1 1 6 4 . a l l ;
−−
entity i n v e r t i s
generic ( d e l a y : time := 0 ns ) ;
port ( i n 1 : in s t d l o g i c ;
out1 : out s t d l o g i c
);
end entity i n v e r t ;
−−
architecture b e h a v i o u r a l of i n v e r t i s
begin
out1 <= not i n 1 a f t e r d e l a y ;
end architecture b e h a v i o u r a l ;
−−
library i e e e ;
use i e e e . s t d l o g i c 1 1 6 4 . a l l ;
−−
entity buf2 i s
port ( i n 1 : in s t d l o g i c ;
out1 : out s t d l o g i c
);
end entity buf2 ;
−−
architecture d a t a f l o w of buf2 i s
begin
out1 <= i n 1 ;
end architecture d a t a f l o w ;
−−
library i e e e ;
use i e e e . s t d l o g i c 1 1 6 4 . a l l ;
−−
use work . a l l ;
−−
entity t e s t b e n c h i s
end entity t e s t b e n c h ;
−−
architecture s t r u c t u r a l of t e s t b e n c h i s
signal data in 1 , data in 2 : s t d l o g i c ;
signal data out 1 , data out 2 : s t d l o g i c ;
signal data control , control buf1 : std logic ;
65
signal r e s u l t : s t d l o g i c ;
−−
begin
p0 : process i s
begin
d a t a i n 1 <= ’ 0 ’ ; wait f o r 5 ns ;
d a t a i n 1 <= ’ 1 ’ ; wait f o r 5 ns ;
end process p0 ;
−−
d a t a i n 2 <= not d a t a i n 1 ;
−−
p1 : process i s
begin
d a t a c o n t r o l <= ’ 1 ’ ; wait f o r 40 ns ;
d a t a c o n t r o l <= ’ 0 ’ ; wait f o r 40 ns ;
end process p1 ;
−−
c1g1 : entity buf port map( i n 1 => d a t a i n 1 , c o n t r o l => d a t a c o n t r o l ,
out1 => d a t a o u t 1 ) ;
c1g2 : entity i n v e r t generic map ( d e l a y => 7 ns )
port map( i n 1 => d a t a c o n t r o l , out1 => c o n t r o l b u f 1 ) ;
c1g3 : entity buf port map( i n 1 => d a t a i n 2 , c o n t r o l => c o n t r o l b u f 1 ,
out1 => d a t a o u t 2 ) ;
c1g4 : entity buf2 port map( i n 1 => d a t a o u t 1 , out1 => r e s u l t ) ;
c1g5 : entity buf2 port map( i n 1 => d a t a o u t 2 , out1 => r e s u l t ) ;
−−
end architecture s t r u c t u r a l ;
66
dtime clk.X int1.R int2.R r1.R r2.R r3.R r4.R bv1.X stdl1.X
0 0 0 99 0.33 99 0 0 000000000 XXXXXXXXX
1e-8 1 1 79 1.33 79 32.7 300 000000000 000000000
2e-8 0 1 79 1.33 79 32.7 300 000000000 000000000
3e-8 1 2 59 2.33 59 105 59.4 000000001 000000001
4e-8 0 2 59 2.33 59 105 59.4 000000001 000000001
5e-8 1 3 39 3.33 39 137 25.3 000000011 00000001X
6e-8 0 3 39 3.33 39 137 25.3 000000011 00000001X
7e-8 1 4 19 4.33 19 130 11.7 000000111 0000001XZ
8e-8 0 4 19 4.33 19 130 11.7 000000111 0000001XZ
9e-8 1 5 -1 5.33 -1 82.3 4.39 000001111 000001XZX
1e-7 0 5 -1 5.33 -1 82.3 4.39 000001111 000001XZX
1.1e-7 1 6 -21 6.33 -21 -5.33 -0.188 000011111 00001XZX0
1.2e-7 0 6 -21 6.33 -21 -5.33 -0.188 000011111 00001XZX0
1.3e-7 1 7 -41 7.33 -41 -133 -3.32 000111111 0001XZX00
1.4e-7 0 7 -41 7.33 -41 -133 -3.32 000111111 0001XZX00
1.5e-7 1 8 -61 8.33 -61 -301 -5.59 001111111 001XZX001
1.6e-7 0 8 -61 8.33 -61 -301 -5.59 001111111 001XZX001
1.7e-7 1 9 -81 9.33 -81 -508 -7.32 111111111 01XZX001X
1.8e-7 0 0 99 9.33 -81 -508 -7.32 111111111 01XZX001X
1.9e-7 1 1 79 10.3 -101 -756 -8.68 111111111 01XZX001X
67
dtime 0 5n 7n 10n 15n 20n 25n 30n 35n 40n 45n 47n 50n 55n 60n 65n 70n 75n 80n
data_in_1.X
data_in_2.X
data_out_1.X Z Z Z Z Z Z Z Z Z
data_out_2.X Z Z Z Z Z Z Z Z Z Z Z
data_control.X
control_buf1.X X X
result.X Z Z
dtime 80n 85n 87n 90n 95n 100n 105n 110n 115n 120n 125n 127n 130n 135n 140n 145n 150n 155n
data_in_1.X
data_in_2.X
data_out_1.X Z Z Z Z Z Z Z Z Z
data_out_2.X Z Z Z Z Z Z Z Z Z
data_control.X
control_buf1.X
result.X Z Z Z
68
program for the 16 bit multiplier including the required data conversion functions.
VHDL debug or message reporting code using the reserved words assert, report and
severity have been added to the data_generator and functional_multiplier
architecture code. During simulation these text strings, and the simulation time
when they were actioned, are written to the Qucs log.txt file, giving a trace record
of the simulation activity. In cases where an error occurs at severity level failure
the simulation will terminate. FreeHDL allows VHDL report statements without
an accompanying assert statement.32 A typical Timing diagram plot for this design
is shown in Fig. 29
X Res_bit
Data 16 bit
16
functional
generator Y 32
multiplier
16
CLK
CLOCK
X => bit_vector(15 downto 0)
−− 16 b i t d i g i t a l m u l t i p l i e r example .
−− S i m u l a t i o n t r a c e u s i n g a s s e r t , r e p o r t and s e v e r i t y s t a t e m e n t s .
−−
entity c l o c k i s
port ( c l k : out b i t ) ;
end entity c l o c k ;
−−
architecture b e h a v i o u r a l of c l o c k i s
begin
p0 : process i s
32
One of the changes at the 1993 revision of the IEEE VHDL 1076-1987 standard was to allow
report statements without the previous mandatory assert clause. FreeHDL attempts to comply
with the 1993 revision.
69
begin
c l k <= ’ 0 ’ ; wait f o r 10 ns ;
c l k <= ’ 1 ’ ; wait f o r 10 ns ;
end process p0 ;
end architecture b e h a v i o u r a l ;
−−
entity d a t a g e n e r a t o r i s
port ( c l k : in b i t ;
x , y : out b i t v e c t o r ( 1 5 downto 0 )
);
end entity d a t a g e n e r a t o r ;
−−
architecture b e h a v i o u r a l of d a t a g e n e r a t o r i s
type mem array 16 i s array ( 1 to 8 ) of i n t e g e r ;
s i g n a l count : i n t e g e r := 0 ;
−−
function i n t e g e r t o v e c t o r 1 6 ( i n t n o : i n t e g e r ) return b i t v e c t o r
is
variable n i : i n t e g e r ;
variable r e t u r n v a l u e : b i t v e c t o r ( 1 5 downto 0 ) ;
begin
assert ( n i < 0 )
report ”Function i n t e g e r t o v e c t o r 3 2 : i n t e g e r number must be >= 0 ”
severity f a i l u r e ;
n i := i n t n o ;
for i in r e t u r n v a l u e ’ Reverse Range loop
i f ( ( n i mod 2 ) =1 ) then r e t u r n v a l u e ( i ) := ’ 1 ’ ;
e l s e r e t u r n v a l u e ( i ) := ’ 0 ’ ;
end i f ;
n i := n i / 2 ;
end loop ;
return r e t u r n v a l u e ;
end i n t e g e r t o v e c t o r 1 6 ;
−−
begin
p1 : process ( c l k ) i s
variable x i : mem array 16 := ( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ) ;
variable y i : mem array 16 := ( 2 , 4 , 6 , 8 , 1 0 , 1 2 , 1 4 , 1 6 ) ;
variable xh , yh : i n t e g e r ;
variable c o u n t i : i n t e g e r ;
begin
c o u n t i := count +1;
70
i f ( c o u n t i > 8 ) then
c o u n t i := 1 ;
end i f ;
xh := x i ( c o u n t i ) ;
yh := y i ( c o u n t i ) ;
x <= i n t e g e r t o v e c t o r 1 6 ( xh ) ;
y <= i n t e g e r t o v e c t o r 1 6 ( yh ) ;
count <= c o u n t i ;
report ”In p r o c e s s p1 . d a t a g e n e r a t o r . ” ;
end process p1 ;
end architecture b e h a v i o u r a l ;
−−
−−
entity f u n c t i o n a l m u l t i p l i e r i s
port ( x , y : in b i t v e c t o r ( 1 5 downto 0 ) ;
r e s b i t : out b i t v e c t o r ( 3 1 downto 0 )
);
end entity f u n c t i o n a l m u l t i p l i e r ;
−−
−−
architecture b e h a v i o u r a l of f u n c t i o n a l m u l t i p l i e r i s
−−
function v e c t o r t o i n t e g e r ( v1 : b i t v e c t o r ) return i n t e g e r i s
variable r e t u r n v a l u e : i n t e g e r : = 0 ;
a l i a s v2 : b i t v e c t o r ( v1 ’ l e n g t h −1 downto 0 ) i s v1 ;
begin
for i in v2 ’ h i g h downto 1 loop
i f ( v2 ( i ) = ’ 1 ’ ) then
r e t u r n v a l u e := ( r e t u r n v a l u e +1)∗2;
else
r e t u r n v a l u e := r e t u r n v a l u e ∗ 2 ;
end i f ;
end loop ;
i f v2 ( 0 ) = ’ 1 ’ then r e t u r n v a l u e := r e t u r n v a l u e +1;
end i f ;
return r e t u r n v a l u e ;
end v e c t o r t o i n t e g e r ;
−−
function i n t e g e r t o v e c t o r 3 2 ( i n t n o : i n t e g e r ) return b i t v e c t o r
is
variable n i : i n t e g e r ;
variable v a l u e : b i t v e c t o r ( 3 1 downto 0 ) ;
begin
71
assert ( n i < 0 )
report ”Function i n t e g e r t o v e c t o r 3 2 : i n t e g e r number must be >= 0 ”
severity f a i l u r e ;
n i := i n t n o ;
for i in 0 to 31 loop
i f ( ( n i mod 2 ) =1 ) then v a l u e ( i ) := ’ 1 ’ ;
e l s e v a l u e ( i ) := ’ 0 ’ ;
end i f ;
i f n i > 0 then n i := n i / 2 ;
e l s e n i := ( ni −1)/2;
end i f ;
end loop ;
return v a l u e ;
end i n t e g e r t o v e c t o r 3 2 ;
−−
begin
p0 : process ( x , y ) i s
variable xi , yi , prod mult : i n t e g e r ;
begin
x i := v e c t o r t o i n t e g e r ( x ) ;
y i := v e c t o r t o i n t e g e r ( y ) ;
prod mult := x i ∗ y i ;
r e s b i t <= i n t e g e r t o v e c t o r 3 2 ( prod mult ) ;
report ”In p r o c e s s p1 . f u n c t i o n a l m u l t i p l i e r ” ;
end process p0 ;
end architecture b e h a v i o u r a l ;
−−
entity t e s t 2 v h d l 1 i s
end entity t e s t 2 v h d l 1 ;
−−
architecture b e h a v i o u r a l of t e s t 2 v h d l 1 i s
signal c l k : b i t ;
s i g n a l x , y : b i t v e c t o r ( 1 5 downto 0 ) ;
s i g n a l r e s b i t : b i t v e c t o r ( 3 1 downto 0 ) ;
−−
begin
d1 : entity work . c l o c k port map ( c l k ) ;
d2 : entity work . d a t a g e n e r a t o r port map( c l k , x , y ) ;
d3 : entity work . f u n c t i o n a l m u l t i p l i e r port map ( x , y , r e s b i t ) ;
end architecture b e h a v i o u r a l ;
72
dtime 10n 20n 30n
clk.X
res_bit.X 00000000000000000000000000001000 00000000000000000000000000010010
x.X 0000000000000010 0000000000000011
y.X 0000000000000100 0000000000000110
Figure 29: Typical timing diagram for the 16 bit functional multiplier.
More advanced output debug messages, and results tables, can be written to Qucs
message file log.txt by using the predefined data handling routines in STD library
package textio33 . This package contains functions for reading and writing STD
data types from and to files34 . The next segment of VHDL code illustrates how a
simple table of results can be written to file log.txt. The results table is shown in
Table 8.
−− Test t e x t i o p a c k a g e .
−−
l i b r a r y STD ;
use STD . t e x t i o . a l l ;
−−
entity Q u c s w r i t e t e s t i s
33
The specification for the FreeHDL package textio can be found in text file freehdl-
0.0.3/std/textio.vhdl.
34
VHDL allows data to be read from and written to the standard input and output streams
as well as user defined files. At this time only writing data to file log.txt and reading data from
user defined data files has been tested. Please note that the use of the textio package is very
much a cutting edge feature of the Qucs/FreeHDL software and is probably not bug free.
73
end entity Q u c s w r i t e t e s t ;
−−
architecture b e h a v i o u r a l of Q u c s w r i t e t e s t i s
begin
w r i t e t e s t : process i s
variable i n p u t l i n e , o u t p u t l i n e : l i n e ;
variable i n t 1 : i n t e g e r := 1 0 ;
begin
write ( output line , string ’ ( ” ” ) ) ;
w r i t e l i n e ( output , o u t p u t l i n e ) ;
w r i t e ( o u t p u t l i n e , s t r i n g ’ ( ” S t r i n g −> l o g . t x t ” ) ) ;
w r i t e l i n e ( output , o u t p u t l i n e ) ;
−−
test L1 : f o r i c in 1 to 5 loop
i n t 1 := i n t 1 + 1 ;
write ( output line , string ’ ( ”int1 = ” ) );
write ( output line , int1 ) ;
write ( output line , string ’ ( ” i n t 1 ˆ2 = ” )
);
write ( output line , int1 ∗ int1 ) ;
w r i t e l i n e ( output , o u t p u t l i n e ) ;
end loop t e s t L 1 ;
report ” F i n i s h e d t e s t f o r l o o p . ” ;
end process w r i t e t e s t ;
end architecture b e h a v i o u r a l ;
74
Output:
----------
Starting new simulation on Thu 24. Aug 2006 at 13:10:56
running C++ conversion... done.
compiling functions... done.
compiling main... done.
linking... done.
simulating...
Output to STD output -> log.txt
int1 = 11 int1^2 = 121
int1 = 12 int1^2 = 144
int1 = 13 int1^2 = 169
int1 = 14 int1^2 = 196
int1 = 15 int1^2 = 225
0 fs + 0d: NOTE: Finished test for loop.
running VCD conversion... done.
Simulation ended on Thu 24. Aug 2006 at 13:10:57
Ready.
Errors:
--------
75
Testing digital systems using test vectors stored on disk.
In an attempt on my part to review all the new features introduced in the previous
sections of this update the final example demonstrates how test vectors stored
on disk, as a text file, can be read by the simulation program at the start of a
simulation, then applied to the inputs of the digital system under test. The code
for this example is given in the following listing:
−− T e s t i n g d i g i t a l c i r c u i t s u s i n g t e s t v e c t o r s
−− s t o r e d as a t e x t f i l e on d i s k .
−−
entity comb1 i s
port ( a , b , c , d : in b i t ;
y : out b i t
);
end entity comb1 ;
−−
architecture d a t a f l o w of comb1 i s
begin
y <= ( a nand b ) or ( c and d ) ;
end architecture d a t a f l o w ;
−−
l i b r a r y STD ;
use STD . t e x t i o . a l l ;
−−
entity t e s t b e n c h i s
end entity t e s t b e n c h ;
−−
architecture b e h a v i o u r a l of t e s t b e n c h i s
signal clock : b i t ;
s i g n a l v1 , v2 , v3 , v4 , y o u t : b i t ;
type a r r a y l i s t i s array ( 1 to 2 0 ) of b i t ;
s i g n a l v1sd , v2sd , v3sd , v4sd : a r r a y l i s t ;
−−
Procedure s t o r e d a t a ( variable number : out i n t e g e r ) i s
variable d1 , d2 , d3 , d4 : b i t ;
variable i n l i n e , o u t l i n e : l i n e ;
variable i : integer ;
variable m y s t r i n g : s t r i n g ( 1 to 2 0 ) := c r & ”C o n s t r a i n e d s t r i n g ” & c r ;
f i l e i n f i l e : t e x t open read mode i s ”/mnt/ hda2 / qucs − 0 . 0 . 1 0 f / t e s t 1 d a t a ” ;
begin
report m y s t r i n g ;
i := 1 ;
while not ( e n d f i l e ( i n f i l e ) ) loop
76
readline ( infile , in line );
r e a d ( i n l i n e , d4 ) ;
r e a d ( i n l i n e , d3 ) ;
r e a d ( i n l i n e , d2 ) ;
r e a d ( i n l i n e , d1 ) ;
v1sd ( i ) <= d1 ;
v2sd ( i ) <= d2 ;
v3sd ( i ) <= d3 ;
v4sd ( i ) <= d4 ;
report ”In f i l e r e a d l o o p . ” ;
i := i +1;
i f ( i > 2 0 ) then e x it ;
end i f ;
number:= i ;
end loop ;
end procedure s t o r e d a t a ;
−−
begin
p0 : process i s −− Generate a c l o c k s i g n a l .
begin
c l o c k <= ’ 1 ’ ; wait f o r 10 ns ;
c l o c k <= ’ 0 ’ ; wait f o r 10 ns ;
end process p0 ;
−−
g0 : entity work . comb1 port map ( v1 , v2 , v3 , v4 , y o u t ) ;
−−
p1 : process i s −− Read t e s t v e c t o r s from d i s k and
−− apply data to c i r c u i t inputs .
variable n o r e a d s : i n t e g e r ;
variable i n l i n e , o u t l i n e : l i n e ;
begin
store data ( no reads ) ;
w r i t e ( o u t l i n e , s t r i n g ’ ( ”count = ”) ) ;
w r i t e ( o u t l i n e , n o r e a d s −1);
w r i t e l i n e ( output , o u t l i n e ) ;
−−
f o r k in 1 to n o r e a d s −1 loop −− Count up .
wait u n t i l ( c l o c k ’ e v e n t and c l o c k = ’ 1 ’ ) ;
v1 <= v1sd ( k ) ;
v2 <= v2sd ( k ) ;
v3 <= v3sd ( k ) ;
v4 <= v4sd ( k ) ;
w r i t e ( o u t l i n e , s t r i n g ’ ( ”Time = ” ) , l e f t , 8 ) ;
77
w r i t e ( o u t l i n e , now , r i g h t , 1 0 ) ;
w r i t e ( o u t l i n e , s t r i n g ’ ( ” Test v e c t o r s −> ” ) , r i g h t , 20 ) ;
w r i t e ( o u t l i n e , v4 , l e f t , 2 ) ;
w r i t e ( o u t l i n e , v3 , l e f t , 2 ) ;
w r i t e ( o u t l i n e , v2 , l e f t , 2 ) ;
w r i t e ( o u t l i n e , v1 , l e f t , 2 ) ;
w r i t e ( o u t l i n e , s t r i n g ’ ( ”k = ” ) , r i g h t , 10 ) ;
write ( out line , k ) ;
w r i t e l i n e ( output , o u t l i n e ) ;
wait u n t i l ( c l o c k ’ e v e n t and c l o c k = ’ 0 ’ ) ;
end loop ;
−−
f o r k in n o r e a d s −1 downto 1 loop −− Count down .
wait u n t i l ( c l o c k ’ e v e n t and c l o c k = ’ 1 ’ ) ;
v1 <= v1sd ( k ) ;
v2 <= v2sd ( k ) ;
v3 <= v3sd ( k ) ;
v4 <= v4sd ( k ) ;
w r i t e ( o u t l i n e , s t r i n g ’ ( ”Time = ” ) , l e f t , 8 ) ;
w r i t e ( o u t l i n e , now , r i g h t , 1 0 ) ;
w r i t e ( o u t l i n e , s t r i n g ’ ( ” Test v e c t o r s −> ” ) , r i g h t , 20 ) ;
w r i t e ( o u t l i n e , v4 , l e f t , 2 ) ;
w r i t e ( o u t l i n e , v3 , l e f t , 2 ) ;
w r i t e ( o u t l i n e , v2 , l e f t , 2 ) ;
w r i t e ( o u t l i n e , v1 , l e f t , 2 ) ;
w r i t e ( o u t l i n e , s t r i n g ’ ( ”k = ” ) , r i g h t , 10 ) ;
write ( out line , k ) ;
w r i t e l i n e ( output , o u t l i n e ) ;
wait u n t i l ( c l o c k ’ e v e n t and c l o c k = ’ 0 ’ ) ;
end loop ;
wait ;
end process p1 ;
end architecture b e h a v i o u r a l ;
Although the listing above is relatively short, careful study of it’s contents should
allow readers to identify many of the new Qucs/FreeHDL features introduced ear-
lier. Moreover in some sections, the code illustrates extra features which will be
familiar to those Qucs/FreeHDL users who have a more advanced knowledge of
the VHDL language. These are listed below with a number of general points:
• The VHDL code simulates the performance of a simple combinational logic
circuit called comb1: this has four inputs (a, b, c, d) of type bit and one
output (y) of type bit35 .
35
Type bit was chosen for this example rather than one of the IEEE signal types because
78
• The testbench being simulated consists of two processes: process p0 generates
a clock signal with a period of 20 ns; process p1 inputs test data held in file
test1_data 36 and stores it in four signal arrays (v1sd, v2sd, v3sd and v4sd),
applying this data to the inputs of the circuit under test at the leading edges
of the clock pulse. Note process p1 only executes once due to the wait
statement at its end.
• The test vector data held in file test_data is read by procedure store_data
which returns the number of lines of data read in variable number. File
handling, including reading data from disk, is undertaken with predefined
routines in package textio.
• Two loops are employed in process p1 to apply signal test vectors to the
input of comb1: the first loop counts up from one and the second loop
counts down from the number of lines of test vectors read by procedure
store_data, effectively generating test vectors in a way similar to using an
up-down pattern generator counter. Note that the signal data is applied to
the circuit under test on the rising edge of the clock signal and that the
applied signal vector sequence is really up to the imagination of the VHDL
programmer.
• The write statements in the process p1 for loops demonstrate the formatted
version of the textio write statement. This greatly assists in setting up
tables of results. Table 9 gives a typical log.txt content for the comb1 test
simulation.
• In process p1 signals v1, v2, v3 and v4 are assigned an indexed value from
(type array_list) v1sd, v2sd, v3sd and v4sd signals. During simulation
package textio does not handle the IEEE multivalue logic types.
36
I use the Knoppix version of the Linux/GNU operating system for all work on the Qucs
project. The absolute location of the test data file will depend on where Qucs and FreeHDL have
been installed and the location where work files are kept.
37
Type character in package standard lists the two letter codes used by VHDL to represent
non-printable control characters.
79
Qucs/FreeHDL stores signal values as a simulation progresses. Hence, it
is theoretically possible to display both the standard and composite signal
types. A typical waveform plot for signals v1, v2, v3, v4 and y_out is given
in Fig. 30. Fig. 31 illustrates a waveform plot of the composite signals v1sd,
v2sd, v3sd and v4sd. In Fig. 31 each group is plotted at a clock edge change
yielding identical groups of values; each vertical set of bits represents the
bit values for a single line in file test1_data. Compare the displayed values
in Fig. 31 with the contents of the test1_data file shown in Fig. 32. As
mentioned before some care is needed when plotting, or tabulating, composite
signals, particularly when the array sizes are large; array dimensions above
roughly 50 become difficult to plot on a normal resolution screen. In such
cases it is better to slice part of an array and assign the required values to a
signal that can be easily displayed.
dtime 0 10n 20n 30n 40n 50n 60n 70n 80n 90n 100n 110n 120n 130n 140n 150n 160n 170n 180n
v1.X
v2.X
v3.X
v4.X
y_out.X
dtime 180n 190n 200n 210n 220n 230n 240n 250n 260n 270n 280n 290n 300n 310n 320n 330n 340n 350n 360n
v1.X
v2.X
v3.X
v4.X
y_out.X
dtime 220n 230n 240n 250n 260n 270n 280n 290n 300n 310n 320n 330n 340n 350n 360n 370n 380n 390n 400n
v1.X
v2.X
v3.X
v4.X
y_out.X
dtime 400n 410n 420n 430n 440n 450n 460n 470n 480n 490n 500n 510n 520n 530n 540n 550n 560n 570n 580n
v1.X
v2.X
v3.X
v4.X
y_out.X
80
Output :
−−−−−−−−−−
S t a r t i n g new s i m u l a t i o n on F r i 25 . Aug 2006 a t 14 : 35 : 48
r u n ni n g C++ c o n v e r s i o n . . . done .
c o m p i l i n g f u n c t i o n s . . . done .
c o m p i l i n g main . . . done .
l i n k i n g . . . done .
simulating . . .
0 f s + 0d : NOTE:
Constrained s t r i n g
0 f s + 0d : NOTE: In f i l e r e a d l o o p .
.
0 f s + 0d : NOTE: In f i l e r e a d l o o p .
count = 16
Time = 0 ns Test v e c t o r s −> 0 0 0 0 k = 1
Time = 20 ns Test v e c t o r s −> 0 0 0 0 k = 2
Time = 40 ns Test v e c t o r s −> 0 0 0 1 k = 3
Time = 60 ns Test v e c t o r s −> 0 0 1 0 k = 4
.
Time = 200 ns Test v e c t o r s −> 1 0 0 1 k = 11
Time = 220 ns Test v e c t o r s −> 1 0 1 0 k = 12
Time = 240 ns Test v e c t o r s −> 1 0 1 1 k = 13
Time = 260 ns Test v e c t o r s −> 1 1 0 0 k = 14
Time = 280 ns Test v e c t o r s −> 1 1 0 1 k = 15
Time = 300 ns Test v e c t o r s −> 1 1 1 0 k = 16
Time = 320 ns Test v e c t o r s −> 1 1 1 1 k = 16
Time = 340 ns Test v e c t o r s −> 1 1 1 1 k = 15
Time = 360 ns Test v e c t o r s −> 1 1 1 0 k = 14
Time = 380 ns Test v e c t o r s −> 1 1 0 1 k = 13
Time = 400 ns Test v e c t o r s −> 1 1 0 0 k = 12
.
Time = 560 ns Test v e c t o r s −> 0 1 0 0 k = 4
Time = 580 ns Test v e c t o r s −> 0 0 1 1 k = 3
r u n ni n g VCD c o n v e r s i o n . . . done .
S i m u l a t i o n ended on F r i 25 . Aug 2006 a t 14 : 35 : 50
Ready .
Errors :
Table 9: An edited version of the formatted tabular output results written to file
log.txt.
81
dtime 40n 50n 60n 70n 80n
v1sd.X 01010101010101010000 01010101010101010000 01010101010101010000 01010101010101010000
v2sd.X 00110011001100110000 00110011001100110000 00110011001100110000 00110011001100110000
v3sd.X 00001111000011110000 00001111000011110000 00001111000011110000 00001111000011110000
v4sd.X 00000000111111110000 00000000111111110000 00000000111111110000 00000000111111110000
Figure 31: Typical timing diagram for composite signals v1sd, v2sd, v3sd and
v4sd.
0 0 0 0
0 0 0 1
0 0 1 0
0 0 1 1
0 1 0 0
0 1 0 1
0 1 1 0
0 1 1 1
1 0 0 0
1 0 0 1
1 0 1 0
1 0 1 1
1 1 0 0
1 1 0 1
1 1 1 0
1 1 1 1
End note
Qucs 0.0.8 added digital simulation to the impressive list of features already avail-
able in the Qucs package. The 0.0.8 release represented a significant step forward
in the development of the Qucs project. The fact that there were bugs in the first
version of the digital simulator was not surprising given the complexity of the soft-
ware. Release 0.0.9 goes a long way to correcting the most annoying of these bugs.
It also adds a number of new features, the most notable being the new VHDL edi-
tor and the automatic generation of component symbols from hand crafted VHDL
82
model code. Qucs 0.0.10 and FreeHDL 0.0.3 adds a range of new features to the
software, particularly important are the use of the IEEE std_logic_1164 package
and the file handling routines found in the textio package. My thanks to Michael
Margraf and Stefan Jahn for all their encouragement during the period that I have
been testing the Qucs VHDL digital simulation and the subsequent writing of these
notes.
83