This course gives you a complete insight into the modern design of digital systems fundamentals from an eminently practical point of view. Unlike other more "classic" digital circuits courses, our interest focuses more on the system than on the electronics that support it. This approach will allow us to lay the foundation for the design of complex digital systems. You will learn a set of design methodologies and will use a set of (educational-oriented) computer-aided-design tools (CAD) that will allow you not only to design small and medium size circuits, but also to access to higher level courses covering so exciting topics as application specific integrated circuits (ASICs) design or computer architecture, to give just two examples. Course topics are complemented with the design of a simple processor, introduced as a transversal example of a complex digital system. This example will let you understand and feel comfortable with some fundamental computer architecture terms as the instruction set, microprograms and microinstructions. After completing this course you will be able to: * Design medium complexity digital systems. * Understand the description of digital systems using high-level languages such as VHDL. * Understand how computers operate at their most basic level (machine language).
L4.4 Short introduction VHDL III (OLD VERSION)
Loading...
来自 Universitat Autònoma de Barcelona 的课程
Digital Systems: From Logic Gates to Processors
177 个评分
从本节课中
Arithmetic components + Introduction to VHDL
<b><font size=4 color=#B22222><b>Click on "v More" to read the purpose of this module</b></font> </b><br/><br/>Arithmetic circuits are an essential part of many digital circuits and thus deserve a particular treatment. <ul><li> The first part of this module presents some implementations of the basic arithmetic operations. Only operations with naturals (non-negative integers) are considered. </li><li>The second part of this module introduces the basics of VHDL with the goal of providing enough knowledge to understand its usage throughout this course and start developing basic hardware models.</li></ul>
与讲师见面
Elena ValderramaProfessor
Departamento de Microelectrónica y Sistemas Electrónicos. UAB.
Jean-Pierre DeschampsProfessor
Lluis TerésProfessor
Centro Nacional de Microelectrónica del CSIC
Merce RullanProfesoraTitular
Departamento de Microelectrónica y Sistemas Electrónicos. UAB.
Joaquín Saiz AlcaineIngeniero Informático
Departamento de Microelectrónica y Sistemas Electrónicos. UAB.
David BañeresProfesor Agregado
Estudios de Informática, Multimedia y Telecomunicación. UOC.
Juan Antonio MartínezCollaborator
APSI - UAB
[MUSIC]
Hello everybody, this is the last lecture devoted to the VHDL language.
We have seen so far, and of course
in a summarized and simplified form, the lexical and
syntax of the language, the basic units like
"Entities" and "Architectures", and the sequential statements.
However, VHDL, was designed to model hardware, to model
circuits, and the different parts of a circuit work,
by nature, simultaneously.
VHDL addresses this challenge through concurrent statements,
which are the main focus of this lecture.
A previous comment:
A VHDL program or VHDL model mainly consist of a "Package" unit that
includes in general definitions of data types, objects, functions and others,
An "Entity" which describes the circuit as
a black box, specifying input and output ports,
and an "Architecture" that models the behaviour of the structure
of the circuit. Well, all the statements
inside the "begin .. end" block of an Architecture must be concurrent. OK?
inside the "begin .. end" block of an Architecture must be concurrent. OK?
In particular, Processes are concurrent structures and, as such,
they can be a part of the Architecture.
Well, Processes are also very special structure because they
can only contain sequential statement inside. OK?
can only contain sequential statement inside. OK?
So, this will be the global aspect of a VHDL model.
In this lecture, we will focus our attention on concurrent statements and
we will devote a couple of slides to seeing how the VHDL is used in practice,
how VHDL is used not only to model hardware
systems, but also to simulate circuits and to automatically synthesize them.
Let's begin with concurrent statements.
Concurrent statements may appear in several VHDL units,
mainly in Architectures, but also in Entities or Blocks.
We won't consider Blocks, in this course.
But to satisfy your curiosity, Blocks are structures that allow
you to group sets of concurrent statements for later use.
In this lesson, we will see the following concurrent statements:
The "Process", very important one;
several variants of the signal assignment;
The declaration and use of components, and the "Generate" statement.
One important point is that any concurrent sentence has a Process equivalent
and, in fact, when a VHDL model is going to be used to simulate a circuit
the compiler translates all concurrent statements to the equivalent Processes,
so the simulator sees the Architecture unit as just a set of Processes.
[BLANK_AUDIO]
Let's see the first of the concurrent statements, the "Process".
The Processes too that, remember, contains only sequential statements
and that runs continuously; it's a kind of infinite loop
controles on one side by "wait" or "stop" statements that control when
the Process is stopped or reactivated, and on the other side
by the sensitivity list, which reactivates the Process
when one event in one of the signals happens.
For a proper functioning a Process must contain some way
to control when to stop and when and how to reactivate.
The sensitivity list is also used for the
Process to communicate with the rest of VHDL code.
This is the syntax of the Process statement: An optional label, followed by the
word "process", optionally followed by the sensitivity list, plus the word "is",
then some local declaration if required, and a "begin .. end" block
where the functioning of the Process is described.
[BLANK_AUDIO]
Here we have two alternative ways to control the execution of a Process.
In the first case, when an event happens on some signal of the sensitivity list,
the Process runs one time and then stops, waiting for a new event.
In the second one, there is no sensitivity list
but the list of signals controlling the reactivation
of the Process has been defined as conditions within a "wait" statement.
Let's go to the next statement, the "signal assignment".
Well, we saw the signal assignment when describing
the sequential statements, and the same conditions apply here.
The signal assignment and some other sentences that we will see later on
can be used in both sequential and a concurrent environment,
but the concurrent signal assignment admits a couple of variants that
the sequential statement doesn't.
We already know the syntax of the signal assignment statement:
An optional label followed by the name of the signal,
followed by the special symbol for the assignment,
the type of delay if any, and the expression whose value
is going to be assigned to the signal, and optionally a delay.
This example shows a description of a Full Adder
by using these three signal assignment sentences.
The only difference with a sequential signal assignment sentence
is that, now, they are supposed to
be in a concurrent environment, as for instance,
an Architecture unit, and thus they will be executed simultaneously.
There exist two variants to the concurrent signal assignment statement,
the "conditional signal assignment"
and the "selected signal assignment".
The conditional signal assignment assigns different values
to a signal depending on which condition holds.
As a matter of fact, the conditional signal assignment is
quite similar to an "if" statement in the sequential world.
We can see here the syntax of the sentence:
An optional label, followed by the signal identifier, plus the special symbol,
a delay_type if any, and then if this condition holds then expres_1
or waveform_1 is assigned to signal; if the second
conditions holds, then expres_2 is assigned to signal, and so on.
It's easy to explain how the conditional signal assignment work over an example.
Here if Sel=0 then A is assigned to S and,
on the contrary, signal B is assigned to signal S.
We said that any concurrent statement has a Process equivalent and that,
in fact, to simulate the circuit the compiler sustitutes all the
concurrent sentences by Processes.
So, here we can see the equivalent
Process of these conditional signal assignment sentence.
Signals appearing at right of the assignment symbol constitute
the sensitivity list of the Process, and in the "begin .. end" block
we have this typical "if .. then .. else" structure.
If Sel=0, then A is, goes to S; and on the contrary, B goes to S.
We can have expressions slightly more complex, like in this second example.
Here if Sel2=00, then E1 is assigned to S,
if Sel2=11, then E2 is assigned to S, and otherwise
the value of S holds (this is the meaning of this word, "unaffected")
the value of S holds (this is the meaning of this word, "unaffected")
saying that otherwise, just do nothing. OK?
saying that otherwise, just do nothing. OK?
And again, there exist an equivalent Process where,
another time, again, the signals appearing at the right of the symbol,
constitute the sensitivity list, and
we have in this "begin .. end" block two nested "ifs", this one
and this one.
Note how this word "unaffected" has been translated here by "null"
with just the same meaning, just do nothing.
In the Selected Signal Assignment different values are assigned to
the signal depending on the value taken by one expression.
Here we have the syntax: If this
expression takes the value 1,
then this expression or waveform is assigned to signal,
if this expression takes the value 2, then this second
expression or waveform is assigned to signal, and so on.
Let's see an example.
Let's assume there exists a data type called "opcode"
that can take the values "add", "subs", "andL" and "orL",
And we have defined a signal opcode, operation, excuse me, with a type "opcode".
This selected signal assignment is telling us that when operation="add"
then Op1+Op2 is assigned to Result; when operation="subs"
Op1-Op2 is assigned to Result, and so on.
As in the previous case, the selected signal assignment
has an equivalent Process like this one, where
we can see that, again, the signals at right
of the assignment symbol constitute as the sensitivity list.
and where the functioning of the
concurrent statement is implemented by a sequential "case".
Let's go to a new concurrent sentence, the "Component".
The "Component" sentence declares components,
and components are blocks or modules, usually
hardware gates, memory elements, or more complex
pieces of circuitry, which has been defined,
has been described, somewhere in the VHDL code,
and that will be used to describe the system
we are modeling at the structural or hierarchical level.
Components are usually defined in the standard user defined
libraries, where the Entities and the
Architectures of these components are specified.
This is the syntax of the "Component" statement:
the word Component, followed by an identifier, plus
the word "is", an optional list of generic parameters
if required, and the list of input output ports.
Once declared we can use these components, we can instantiate the component by
writing its name, and set another timer of optional generic parameters,
and associating
the input output ports with the signal that
will actually enter to or out from
this particular copy, this particular instantiation of the component.
Here we have an example. A component named
"example" has been declared, having input ports "a",
"b", "c", and one output port "d". Here,
we are associating input-output ports to signals
"X", "Y", "W", and "Z". We are saying that, in this particular instantiation
signal "X" will enter to port "a", signal "Y" will enter to port "b",
signal "W" will enter to port "c", and the
output port "d" will go into signal "Z".
In this case, we are associating ports and signals
by position, but we can make this instantiation by name, like here:
We are telling the same information, specifying that the
output port "d" will be assigned to signal "Z", that signal "X"
will enter to port "a", signal "Y" will enter into port "b", and so on.
Another more complex example:
Let's assume we want to model our famous and very well known Full Adder, OK?
Let's assume we want to model our famous and very well known Full Adder, OK?
We defind the Entity as a black box having
3 1-bit input ports, "X", "Y", and carry-IN.
And 2 output ports, carry-OUT and "Sum". We are going to build the
Architecture by using two components; component "HalfAdder", and the component
"OrG". The component HalfAdder has 2 input ports, I1
and I2, and 2 output ports COut, and Sum.
As a matter of fact, HalfAdder is simply an Adder
for two 1-bit numbers without any input carry.
And here we have the declaration of the OR gate, OrG,
Which is a component with 2 inputs I1 and I2, and an output O.
Once declared, we can use them in the
"begin .. end block" in order to describe this structure.
We have a first instantiation of the HalfAdder here, assigning signals
X, Y, A and B to the input and output ports.
You see X and Y are assigned to the input ports of this HalfAdder,
and signals A and B are assigned to the outputs.
A second instantiation is describing this second HalfAdder assigning
signals B and CarryIn to the input, and C and Sum to the output.
And finally we have here a copy, an instantiation of
the OrG, having as inputs A and C, and having
COut as the output. See how
in the two first cases we are using a positional association list
and in the third case we are associating signals and ports by name.
Somewhere in the VHDL model, there is some
library where wee have a definition of the functionality
of the HalfAdder and the OrG components
in terms of, well, a table like this one.
Sentence "Generate" is also very important. It's used to generate
arrays of component instances. This is the syntax.
There are two variants, one with a "for" plus a range of specification, and
another with an "if" plus some condition. Let's see a simple example:
let's assume we are building an N-bit register. Remember,
this register is just a device capable of storing N bits of information.
And we want to build this register as an array of N components
called DFF. We have the
Entity, defined here with inputs and outputs.
Our circuit allows to enter N-bits of information in parallel,
and outputs also in parallel N-bits of information,
so that's why we have defined output E and output S,
as vectors from N-1 to N. Another signal,
another input signal "clock" is needed to properly synchronize
the functioning of all the DFF blocks.
Don't worry right now, because we will
discuss the topic of synchronization next week.
We declare also a generic value, N, that will allow
to resize the registers when we want to. In the Architecture,
we define the component, and variable I
that will be used as index for the Generate sentence,
and here, in the "begin .. end" block you see how
we use the Generate to instantiate
N times the DFF block connecting, in
each step, the clock signal, to all
DFF to the port clock with the same
name, the signals E from N-1
to 0 to the input ports with the same
name,and the signals S from N-1
to 0 to the output port with the same name.
Well, see how easy it is to model this
circuit by using an only, a unique Generate sentence.
Finally sentences "assert", "procedures", and "functions".
as the simple version of the signal assignment
sentence, are statements identical to their sequential counterparts.
That is, they are statements that execute
sequentially or concurrently depending on their environment.
So, well, nothing to add to what we
saw in the lecture devoted to sequential statements.
With this, we conclude the topic of the concurrent statements.
But, before ending the set of lectures devoted VHDL,
I would like to introduce and briefly discourse the last important topic:
How VHDL models are used to simulate and synthesize, digital systems.
How do we face the design of, let's say, a big digital circuit.
Well, we start with the specifications of the system
and we, let's say, polish them up to the point in which we can build
a model of the circuit using, in general, a hardware description language.
I'm using the
generic term HDL: "Hardware Description Language",
because VHDL is not the only one.
Nowadays two languages are widely used to describe the hardware.
One is of course the VHDL and the other is Verilog.
VHDL is more structured, it ia a more structured and algorithm language than
Verilog, and this is the reason why we selected VHDL for this course.
Well, we are saying that we refine the specifications
and we finally have an HDL model of the system to design.
Then we enter this model to the simulator, ...
We will have to add to the VHDL model a description of the values,
of the input signals, that the system is going to receive along time,
what are called the "stimuli" to the system. Simulators compute and
display the values that outputs and even internal signals take at any time and,
with this, we can check if the output
values delivered by the system match with our initial specifications.
If no, if there is no match, we will
have to check the stimuli and simulate
another time, or check the
model, or even check our initial
specifications. Well, after several passes, we will
hopefully get simulation results that match with our specifications,
and then we will proceed to synthesize the system.
We will synthesize the circuit by using this, let's say,
refined VHDL model that matches with our initial specifications.
To do so we use automatic synthesis tools capable of building the
VHDL model by using a particular component library and a particular technology.
The synthesis tool demands the VHDL model, the component library,
and a set of synthesis criteria as, for instance, do it prioritice speed,
that is, a circuit as quick as quick as possible;
or cost, a circuit containing the minimal
number of devices; or maybe power consumption. conservation.
Now let's see
see a small example to try to understand how simulation runs.
Here we have the VHDL model of a very simple circuit.
The Entity doesn't contain any input-output port,
so the circuit is self contained.
The Architecture consists of two Processes:
The first one describes the function to implement and the second one defines
the values that inputs "a", "b", and "opcode" will take during the simulation.
The first Process is defining what we name the "function under test",
and the second defines what we call the "test vector wavefroms", or the
stimuli to the circuit. Lets analyze the the waveforms. See here,
that at time t=0, "a" takes the value of 0110,
"b" the value of 0101 and "opcode"
the value "add", and then this Process stops
and waits for 100 nanoseconds.
After 100 nanoseconds the value of "opcode" changes to "sub",
and the rest of the values of the inputs remains unchanged.
And, another time, the Process stops and wait for 100 nsec.
After this second 100 nsec
"b" takes the value 1001 and wait another time
for 100 nsec. See here that finally, "opcode"
takes the value "addA" and then the Process goes to
unconditional "wait" statement that stops completely
the Process and never reactivates. The result of all
these input assignments is this wavefrom
we see here, OK?
See how at t=0 we are here, a=0110, b=0101.
See how at t=0 we are here, a=0110, b=0101.
thses two values, and "opcode" takes the value "add".
Then, 100 nanoseconds later, "opcode" changes to "sub" and the other
two inputs remain unchanged, OK?.
Let's see what happened with the function under test Pprocess.
When one signal "a", "b" or "opcode" change their value
and an event on the sensitivity list of the Process happens.
The Process is executed and it stops waiting for a new event in the sensitivity
list since, as you can see, it
doesn't contain any conditional or unconditional "wait" statement.
Any Process executes at least once,
so the first time we will have here then a=6
(I'm going to use the decimal, the base 10
notation for numbers), b=5
and opcode=add. "a" is greater than "b" so
"x" is set to "a", "y" is set to "b", "s" takes
the value 0 and that finish the if-condition
and then we go to the "case" statement,
"opcode" is equal to "add", so "z" takes the value x+y
that is 11, which in reality is 1011,
and "sign" is set to 0. OK, that's what we have here.
Then, the Process function under test stops waiting
for a new change in the sensitivity list.
And this change happens exactly here, at t=100 nsec, time equal
when "opcode" changes its value to "sub". OK?
when "opcode" changes its value to "sub". OK?
So the Process reanudates
and we will have that "a" and "b" have the same value, so "x" and "y"
"s" will have also the same values. But, the "opcode" is now "sub".
So, when "sub" sets the value x-y, that is,
6-5=1, or 0001 in binary,
and "sign" is set to 0, OK?.
Another time, again, Process stops and wait for a new change in the
sensitivity list that happens at time t=200 nsec
and in this case, "a" has the value 6, but "y" has changed to 9.
OK? So,
excuse me, this is "b", so as now,
"b" is greater than "a", we have
x=v, y=a, and s=1.
x=v, y=a, and s=1. "Opcode" is "sub", so
"z" takes the value x-y, 9-6=3, or 0011,
"z" takes the value x-y, 9-6=3, or 0011,
and "sign" is set to the value
of "s", which is 1, OK?
This is the next step, again the Process stops and reactivates at the t=300nsec
and finally here, what we have is that "a" and "b" don't change.
So we have the same value for "a, "b", "x", "y" and "s".
The "opcode" is "add", so, I go on here,
OK, "z" takes the value x+y, 6+9=15, 0r 1111 in binary,
OK, "z" takes the value x+y, 6+9=15, 0r 1111 in binary,
and "sign" is set to 0, this situation.
And that stops the simulation because this Process, you remember,
has a "wait", a conditional "wait" statement here that stops this Process.
As this Process stops there is no change
in the sensitivity list of the function under test Process.
So this second Process also stops.
OK, understand?, ... I hope so.
Let's see another example, now using actual simulation and synthesis tools.
This VHDL code models, again the very well
known ParallelAdder that we have discussed several times.
And in particular, we are now considering a 4 bit ParallelAdder.
This is the screen of one simulation. You can see here input "x", "y"
and carry-in, and here the output "z".
and, well, you can see all the changes,
this waveforms, analyze them and, when we decide that
the simulation is correct, that fits with the initial
specifications, we will run the synthesis tools that will obtain,
in this case, the gate level schematics shown here.
The circuit implements the sum of x+y+carry-in, being "x" and "y" 4-bit
binary numbers, and carry-in a 1 bit input carry, OK, clear?
binary numbers, and carry-in a 1 bit input carry, OK, clear?
All of this is done automatically. So, well, this
is how VHDL is used in the design process of big
digital circuits.
So this concludes this session devoted to concurrent statements,
where we have introduced also a brief discussion
of how VHDL models are used in the design of digital systems.
And this concludes also the short, or maybe not too short,
introduction to VHDL, which goal, remember, was not
to become you a skilled VHDL programmer but to let you know the basics of the
language in order to be able to understand simple VHDL descriptions
and in particular those VHDL models that we
will introduce in the rest of the course.
Thank you very much for your attention.
[BLANK_AUDIO]
