Introduction to VHDL

part 1

Fall 08

1
 Preliminary
• Class web page
http://www.people.vcu.edu/~jhtucker/f08-
egre365/index.html
• Syllabus Grades:
– Quizzes (2) 40%
– Homework 10%
– Laboratory 10%
– Design Project 15%
– Final Exam 25%
• Text book The Student’s Guide to VHDL.
– This will be used primarily as a reference.

2
 What is VHDL?
• We will use VHDL to model digital systems.
• VHDL = VHSIC Hardware Description Language
– VHSIC = Very High Speed Integrated Circuit
• Developed in 1980’s by DOD.
• Veralog is an older hardware description language.
– Some (for example ASIC designers) prefer Veralog.
• ANSI/IEEE Std 1076-2002 is the version we will use.
– ANSI/IEEE Std 1076-2008 is the newest version.
• VHDL is a very complex language.
• A system can be described and simulated using VHDL.
• VHDL descriptions can be synthesized and implemented
in programmable logic.
– Synthesis tools can accept a only subset of VHDL.
3
 VHDL
• Primarily for modeling digital systems.
– Lesser extent analog
– We will consider only digital systems
• Reasons for modeling
– Specify requirements
– Simulation, testing, verification
– Synthesis
• Advantage
– Increase reliability
– Minimize cost and design time
– Increase flexibility and ease with which a system can be modified.
– Avoid design errors through use of simulation.
• Problem
– We model our conception of the system.
– May not accurately reflect reality.

4
 A VHDL program
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity ABorC is
port (A : in std_logic;
B : in std_logic;
C : in std_logic;
F : out std_logic);
end ABorC;
architecture arch of ABorC is
signal X : std_logic;
begin
X <= A and B after 1 ns;
F <= X or C after 1 ns;
end; 5
 Types chapter 2
• The concept of type is important and fundamental when describing
data in VHDL.
• The type of a data object defines the set of values that an object can
assume, as well as the set of operations that can be performed on those
values.
– For example data object of type bit can assume a value of either ‘0’ or ‘1’,
and can support operators such as “and”, “or”, “xor”, “nand”, etc.
• Each object in VHDL has to be of some type.
• VHDL is a strongly typed language.
• Scalar data types consists of single, indivisible values.
• Besides the usual types such as integer and real, VHDL also provides
other types such as time and bit.
• User defined types are frequently employed.
• We will make extensive use of standard libraries that define special
types such as stdlogic.
– We will use stdlogic in place of bit. Stdlogic can assume more values that
0 and 1. For example high impedance and don’t care values.
6
 VHDL type classification
See SG p 51, DG p 47.

10 ns
125

“101110001110001”
FALSE ‘1’ 7
‘A’
 Operations that can be performed on type integer. See SG p 36, DG p 35

Use parentheses to force desired

Precedence.

8
 Operations on type Boolean and type Bit. See p46

Note: For type bit replace false with ‘0’ and true with ‘1’.

Legal

9
Not legal
 Constants, variables, and signals
• An object is a named item in a VHDL model that has a value of a
specific type. There are four classes of objects: constants, variables,
signals, and files.
• The use of constants and variables in VHDL is similar to what you are
already familiar with from other programming languages.
• The idea of a signal is a new concept required because in VHDL we
are modeling electrical (digital) systems.
– Signals usually represent voltages on wires.
– But you can also use a signal in place of a variable.
– Sometimes it may not matter if you use a signal or a variable.
– Other times there may be subtle reasons for using one over the other.
– Initially you may tend to be confused by the distinction between signals
and variables, but this will be made clear later.
• We will postpone the discussion of files till later.
• Objects must be declared prior to use.

10
 Constants
constant CONST_NAME: <type_spec> := <value>;
-- Examples of Declaration of Constants:
constant GO: BOOLEAN := TRUE;
constant Max: INTEGER := 31;
constant HexMax: INTEGER := 16#FF#; -- hex (base 16) integer
constant ONE: BIT := '1';
constant S0: BIT_VECTOR (3 downto 0) := "0000";
constant S1: bit_vector(15 downto 0) := X"AB3F“; -- hex string
constant HiZ: STD_LOGIC := 'Z'; -- Here Z is high impedance.
constant Ready: STD_LOGIC_VECTOR (3 downto 0) := "0-0-"; -- 0’s &
don’t cares
Note: VHDL is not case sensitive. -- is used for comments.
• BOOLEAN, INTEGER, BIT, etc are examples of predefined VHDL types.
– VHDL is a strongly typed language.
– Cannot for example directly assign a bit or std_logic value to an integer type.

11
 Variables
VAR_NAME := <expression>;
-- example
Count := 10;
Vbit := '0';
• Declaration
variable VAR_NAME: <type_spec>;
-- example:
variable Test: BOOLEAN;
variable Count: INTEGER range 0 to 31 := 15; -- Set initial value to 15.
variable vBIT: BIT;
variable VAR: BIT_VECTOR (3 downto 0);
variable VAR_X: STD_LOGIC := ‘0’; -- Set initial value to ‘0’.
variable VAR_Y: STD_LOGIC_VECTOR (0 to 3);

12
 Signals
SIG_NAME <= <expression>;
-- Examples
BitX <= ‘1’;
• Declaration
signal SIG_NAME: <type_spec>;
-- example:
signal Flag: BOOLEAN := TRUE; -- TRUE is the initial vlaue
signal intX: INTEGER range 0 to 31;
signal BitX: BIT := ‘1’;
signal Control_Bus: BIT_VECTOR (3 downto 0);
signal X: STD_LOGIC;
signal Y: STD_LOGIC_VECTOR (0 to 3) := “0000”;

13
 Signals
Events, Propagation Delay, and Concurrency
• Signals
– Signals of type bit take on values of 0 and 1.
– Digital components (gates, flip-flops, etc.) respond to input signals to
produce output signals.
– A signal change is called an event.
– The effect of an event is delayed by the propagation delay through the
component. VHDL allows for associating a delay with a signal.
• Z <= X and Y after 2 ns;
– Signals may propagate through several components concurrently.
Z <= X and Y after 2 ns;
An event on X may cause an event on
V <= (Z xor not W) nand X after 3 ns; some or all of the signals Z, V, and W.
W <= X or Y after 1 ns;
– VHDL is an event driven concurrent programming language.
• Statements don’t necessarly execute sequentially.
• This makes VHDL “hard.”

14
 VHDL example EX 1
--EX1.vhd
ENTITY tb is END tb;
ARCHITECTURE test OF tb IS
signal X : BIT;
BEGIN
X <= not X after 10 ns;
END test;

15
--EX2.vhd
ENTITY tb is END tb;
ARCHITECTURE test OF tb IS
signal X, Y : BIT;
BEGIN
X <= not X after 10 ns;
Y <= '1' after 5 ns, '0' after 12 ns, '1' after 25 ns;
END test;

16
--EX3.vhd
ENTITY tb is END tb;
ARCHITECTURE test OF tb IS
signal X, Y : BIT;
signal Z, Z1, Z2: BIT;
BEGIN
X <= not X after 10 ns;
Y <= '1' after 5 ns, '0' after 12 ns, '1' after 25 ns;
Z <= X or Y after 1 ns;
Z1 <= (X and Y) xor Z;
Z2 <= Z xor (X and Y);
END test;

17
 Another VHDL example EX4

-- EX4 - Signal example -- concurrent signals assignments

-- File: ex4.vhd X <= not X after 10 ns;
entity ex4 is Y <= not Y after 25 ns;
end entity ex4; Z <= X and Y after 2 ns;
V <= (Z xor not W) nand X after 3 ns;
architecture ex_arc of ex4 is W <= X or Y after 1 ns;
signal X: BIT; end architecture ex_arc;
signal Y: BIT;
signal Z, V, W: BIT;
begin

18
X <= not X after 10 ns;
Y <= not Y after 25 ns;
Z <= X and Y after 2 ns;
V <= (Z xor not W) nand X after 3 ns;
W <= X or Y after 1 ns;

19
 std_logic_1164 multi-value logic system
TYPE std_ulogic IS ( 'U', -- Uninitialized
'X', -- Forcing Unknown
'0', -- Forcing 0
'1', -- Forcing 1
'Z', -- High Impedance
'W', -- Weak Unknown
'L', -- Weak 0
'H', -- Weak 1
'-' -- Don't care );

20
‘X’ indicates an unknown value. This can be caused by the resolution
function as shown below.
resolution function – resolves two drives for a single
signal. Std_logic has a built in resolution function.
S <= ‘1’; Don’t drive signal from
S <= ‘0’; multiple sources!
CONSTANT resolution_table : stdlogic_table := (
-- ---------------------------------------------------------
-- | U X 0 1 Z W L H - | |
-- ---------------------------------------------------------
( 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', 'U' ), -- | U |
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ), -- | X |
( 'U', 'X', '0', 'X', '0', '0', '0', '0', 'X' ), -- | 0 |
( 'U', 'X', 'X', '1', '1', '1', '1', '1', 'X' ), -- | 1 |
( 'U', 'X', '0', '1', 'Z', 'W', 'L', 'H', 'X' ), -- | Z |
( 'U', 'X', '0', '1', 'W', 'W', 'W', 'W', 'X' ), -- | W |
( 'U', 'X', '0', '1', 'L', 'W', 'L', 'W', 'X' ), -- | L |
( 'U', 'X', '0', '1', 'H', 'W', 'W', 'H', 'X' ), -- | H |
( 'U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' ) -- | - |
21
);
 Why have ‘U’ in std_logic types?
• Any uninitialized type assumes the left most value of that
type.
– TYPE std_logic IS ( 'U', 'X', '0', '1', 'Z', 'W', 'L', 'H', '-' );
– TYPE BIT is (‘0’, ‘1’);
• What is the initial value?
variable vBIT: BIT;
variable VAR_X: STD_LOGIC := ‘0’;
signal BitX: BIT := ‘1’;
signal X: STD_LOGIC;
Signal N: integer;

22
Recall EX2: Let’s use std_logic in place of bit.
--EX2.vhd
ENTITY tb is END tb;
ARCHITECTURE test OF tb IS
signal X, Y : BIT;
BEGIN
X <= not X after 10 ns;
Y <= '1' after 5 ns, '0' after 12 ns, '1' after 25 ns;
END test;

23
--EX2.vhd Using STD_LOGIC ARCHITECTURE test OF tb IS
LIBRARY IEEE; signal X, Y : STD_LOGIC;
USE IEEE.std_logic_1164.ALL; BEGIN
ENTITY tb is END tb; X <= not X after 10 ns;
Y <= '1' after 5 ns, '0' after 12 ns, '1' after 25 ns;
END test;

24
 What happened?

• In VHDL uninitialized signals and variables assume the left most value of the
type.
– STD_LOGIC initializes to “U”.
X <= not X after 10 ns;
Y <= '1' after 15 ns, '0' after 25 ns;
-- truth table for "not" function
CONSTANT not_table: stdlogic_1d :=
-- -------------------------------------------------
-- | U X 0 1 Z W L H - |
-- -------------------------------------------------
( 'U', 'X', '1', '0', 'X', 'X', '1', '0', 'X' );

25
 ENTITY tb is END tb;
--EX2.vhd Using STD_LOGIC
ARCHITECTURE test OF tb IS
-- with initialization
signal X: STD_Logic := '1';
LIBRARY IEEE;
Signal Y : STD_LOGIC := '0';
USE IEEE.std_logic_1164.ALL;
BEGIN X <= not X after 10 ns; Y <=
ENTITY tb is END tb;
'1' after 5 ns, '0' after 12 ns, '1' after 25
ns; END test;

26
 A more complicated example using IEEE.STD_LOGIC_ARITH
LIBRARY IEEE;
USE work.all;
USE IEEE.Std_Logic_1164.all;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
ENTITY tb is END tb;
ARCHITECTURE test OF tb IS
constant ALL_ONES: std_logic_vector(3 downto 0) := X"F";
constant Some_Ones: std_logic_vector(3 downto 0) := X"A";
SIGNAL Q : std_logic_vector(3 downto 0) := (others => '0'); --"0000";
signal X : std_logic_vector(3 downto 0);
BEGIN
Q <= Q(2 downto 0) & not Q(3) after 5 ns;
X <= ALL_ONES after 10 ns, Some_Ones after 15 ns, "0000" after 20 ns;
END test;

27
LIBRARY IEEE; Same example using numeric package.
USE work.all;
USE IEEE.Std_Logic_1164.all; The numeric package defines unsigned to be a
std_locic_vector that is treated as an unsigned
use ieee.numeric_std.all; vector. (You can also have a signed vector).
ENTITY tb is END tb;
ARCHITECTURE test OF tb IS
constant ALL_ONES: unsigned(3 downto 0) := X"F";
constant Some_Ones: unsigned(3 downto 0) := X"A";
SIGNAL Q : unsigned(3 downto 0) := (others => '0'); --"0000";
signal X : unsigned(3 downto 0);
BEGIN
Q <= Q(2 downto 0) & not Q(3) after 5 ns;
X <= ALL_ONES after 10 ns, Some_Ones after 15 ns, "0000" after 20 ns;
END test;

28
 And Or gate in VHDL example
A 2
1 X 2
B 3 1 F
3
C
library IEEE;use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL; Instead of the numeric
package we will normally
entity ABorC is use the arithmetic
port (A : in std_logic; B : in std_logic; package and the
C : in std_logic; F : out std_logic); associated unsigned
package. But the numeric
end ABorC; package would work
architecture arch of ABorC is equally well.
signal X : std_logic;
begin
X <= A and B after 1 ns;
F <= X or C after 1 ns;
end; 29
LIBRARY IEEE;USE work.all; Test bench for
USE IEEE.Std_Logic_1164.all;
use IEEE.STD_LOGIC_ARITH.ALL;
and or example
use IEEE.STD_LOGIC_UNSIGNED.ALL;
ENTITY tb IS END ENTITY tb;
Architecture TEST of tb is
SIGNAL X: std_logic_vector (2 downto 0) := "000";
SIGNAL Y: std_logic;begin
U1: ENTITY work.ABorC(arch)
PORT MAP(A => X(2), B => X(1), C => X(0), F => Y);
X <= X + 1 after 10 ns;
end test;

30
 A
A U2 F AB
B
B
AND2

A A
U3 F BCin B
U1 F
B C Cout
Cin
AND2 OR3

A
U4 F ACin
B
AND2
A A
U5 F AxorB A
B B
U6 F
B S
XOR2
Cin XOR2
U1: entity work.or3 port map
(A => AB, B => ACin , C => BCin , F => Cout);
U2: entity work.and2 port map
(A => A, B => B, F => AB);
U3: entity work.and2 port map
(A => B, B => Cin, F => BCin);
U4: entity work.and2 port map
(A => A, B => Cin, F => ACin);
U5: entity work.xor2 port map (A, B, AxorB);
U6: entity work.xor2 port map (Cin, AxorB, S);
31
 VHDL design units
• Configuration
• Package See DG chapter 5
• Package Body
• Entity
– Describes Interface
• Describes how the circuit appears form the outside.
• Similar to a schematic symbol.
• Architecture
– Specifies function
• Describes how the circuit does what it does.
– RTL
– Behavioral
– Structural
• Initially we will focus on the Entity and Architecture.
– Both are always necessary the others are optional.

32
 Process
• The process is a fundamental concept in VHDL
• Processes are contained within an architecture.
– An architecture may contain several processes.
• Processes execute concurrently (at the same time)
– Code within a process execute sequentially. (See chapter 3.)
• Combinational circuits can be modeled without using
process.
• Sequential circuits need processes.
• Processes provide powerful statements not available
outside processes.
Example Sensitivity list
process (A, B)
F <= A xor B;
end process;
33
 Process

• Process statements occur within an architecture.

• The syntax for a process is:
LABEL1: -- optional label
process (signal_name, …) is
-- declarations
begin
-- sequential statements

end process LABEL1;

34
 Process example

• Without process statements • With process statements

architecture ex_arc of ex4 is Process(X) begin
signal X: BIT; X <= not X after 10 ns;
signal Y: BIT; End process;
signal Z, V, W: BIT; P2: process(y) begin
Begin Y <= not Y after 25 ns;
-- concurrent signals assignments End process P2;
X <= not X after 10 ns; P3: Process(X,Y,Z,W)
Y <= not Y after 25 ns; begin
Z <= X and Y after 2 ns; Z <= X and Y after 2 ns;
V <= (Z xor not W) nand X after 3 ns; V <= (Z xor not W) nand X after 3 ns;
W <= X or Y after 1 ns; End process P3;
end architecture ex_arc; P4: process(X,Y) begin
W <= X or Y after 1 ns;
End process P4;

35
A VHDL example illustrating that signals are updated when the process suspends.
ARCHITECTURE test OF tb IS
signal CLK: std_logic := '0'; -- Initial vlaue of '0'
signal X: INTEGER := 0; -- Initial value of 0
BEGIN
-- Make the signal CLK changes every 10 nsec.
CLK <= not CLK after 10 ns; -- CLK changes every 10 nsec
-- States within a process execute sequentially
-- All process are activated at time t = 0.
-- The process below is also activated when CLK changes.
process (CLK)
variable I: INTEGER := 0; -- Initial value of 0
begin
I := I + 3; The process is activated at time t =
0 and when signal CLK changes.
X <= X + 3;
I := I + 2;
X <= X + 2;
I := I + 1;
X <= X + 1; Signals are not updated
end process; until the process
END test; suspends.
36
 A VHDL example continued
CLK <= not CLK after 10 ns;
process (CLK)
variable I: INTEGER := 0; -- Initial value of 0
begin -- signal X is an integer with initial value of 0
I := I + 3;
X <= X + 3;
I := I + 2;
X <= X + 2;
I := I + 1;
X <= X + 1;
end process;
END test;

37
 Example mod 10 counter
LIBRARY IEEE; Architecture Example of ExMod10 is
USE work.all; begin
USE IEEE.Std_Logic_1164.all; DoCount: process(clk) is
use ieee.numeric_std.all; begin
if falling_edge(clk) then
ENTITY ExMod10 IS if count < 9 then
count <= count+1;
PORT
else
(
count <= 0;
CLK: in std_logic;
end if;
Count: BUFFER integer range 0 to 9 end if;
); end process DoCount;
END ENTITY ExMod10; end architecture Example;

38
LIBRARY IEEE;
begin
VHDL 87 Test bench
USE work.all;
USE IEEE.Std_Logic_1164.all; DUT: ExMod10
use IEEE.numeric_std.all; PORT MAP
ENTITY tb IS END ENTITY tb; (
Architecture TEST of tb is
CLK => C, -- Clock at 100 MHz
SIGNAL C: std_logic := '0';
Count => CNT
SIGNAL CNT: integer range 0 to 9;
);
COMPONENT ExMod10
PORT ( CLK: in std_logic; C <= not C after 5 ns;
Count: BUFFER integer range 0 to 9 ); end test;
END COMPONENT ExMod10;

39
 Alternative simpler test bench possible with VHDL 93

LIBRARY IEEE; begin

USE work.all; DUT: ENTITY ExMod10
USE IEEE.Std_Logic_1164.all; PORT MAP
use IEEE.numeric_std.all; (
ENTITY tb IS END ENTITY tb; CLK => C, -- Clock at 100 MHz
Architecture TEST of tb is Count => CNT
SIGNAL C: std_logic := '0'; );
SIGNAL CNT: integer range 0 to 9;
C <= not C after 5 ns;
--end architecture TEST;
end test;

40
 An alternative architecture
LIBRARY IEEE; Architecture Example of ExMod10 is
USE work.all; begin
USE IEEE.Std_Logic_1164.all; DoCount: process(clk) is
use ieee.numeric_std.all; begin
if falling_edge(clk) then
ENTITY ExMod10 IS -- if count < 9 then
PORT count <= count+1;
( -- else
CLK: in std_logic; -- count <= 0;
Count: BUFFER integer range 0 to 9 -- end if;
); end if;
END ENTITY ExMod10; end process DoCount;
end architecture Example;

41
 Using OUT instead of BUFFER
Note: Here we are using IEEE.STD_LOGIC_ARITH.ALL

LIBRARY IEEE;
USE work.all;
USE IEEE.Std_Logic_1164.all;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

ENTITY ExMod10 IS
PORT
(
CLK: in std_logic;
Count: OUT integer range 0 to 9
);
END ENTITY ExMod10;
42
 Using a temporary signal CNT.

Architecture SIG of ExMod10 is

signal CNT: INTEGER RANGE 0 TO 9;
begin
DoCount: process(clk) is
begin
if CLK'EVENT AND CLK = '0' then
CNT <= (CNT+1) mod 10;
end if;
end process;
Count <= CNT;
end architecture SIG;

43
 Alternative architecture using a temporary variable.
Architecture VAR of ExMod10 is
begin
DoCount: process(clk) is
variable vcount: integer range 0 to 9;
begin
if clk’event and clk = ‘0’ then
vcount := (vcount + 1) mod 10;
count <= vcount;
end if;
end process DoCount;
end architecture VAR;

44
LIBRARY IEEE;
USE work.all;
A test bench
USE IEEE.Std_Logic_1164.all;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
ENTITY tb IS END ENTITY tb;
ENTITY tb IS END ENTITY tb;
Architecture TEST of tb is
SIGNAL C: std_logic := '0';
SIGNAL Count_sig: integer range 0 to 9; Must specify
signal Count_var: integer range 0 to 9; the particular
begin architecture.
DUT: ENTITY work.ExMod10(SIG)
PORT MAP
( CLK => C, -- Clock at 100 MHz
Count => Count_sig );
DUT2: ENTITY work.ExMod10(VAR)
PORT MAP
( CLK => C, -- Clock at 100 MHz
Count => Count_var );
C <= not C after 5 ns;
--end architecture TEST;
end test; 45