0% found this document useful (0 votes)
128 views

LHO 01 - Introduction To VHDL Part 1

This document provides an introduction to VHDL and discusses key concepts about the language. It outlines the grading breakdown for the class and introduces VHDL's use for modeling digital systems. The document then covers VHDL program structure, types, constants, variables, signals, and modeling concurrent logic. Examples are provided to demonstrate VHDL syntax and modeling simple digital logic.

Uploaded by

Hanmant Gore
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
128 views

LHO 01 - Introduction To VHDL Part 1

This document provides an introduction to VHDL and discusses key concepts about the language. It outlines the grading breakdown for the class and introduces VHDL's use for modeling digital systems. The document then covers VHDL program structure, types, constants, variables, signals, and modeling concurrent logic. Examples are provided to demonstrate VHDL syntax and modeling simple digital logic.

Uploaded by

Hanmant Gore
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 45

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

You might also like