HDL Lab Manual
HDL Lab Manual
CONTENTS
Sl. NO Title Page No
1 Syllabus 2
2 Cycles of Experiments 4
4 Introduction to FPGA 17
6 Viva Questions 69
1. SYLLABUS
Subject code:15ECL58 IA marks:20
No. of practicalHrs. /week:03 Exam hours:03
Total no. of practical Hrs.42 Exam marks:80.
…………………………………………………………………………
(ACCORDING TO VTU SYLLABUS)
PART – A
3. Write a HDL code to describe the functions of a full adder using three modeling styles.
4. Write a model for 32 bit ALU using the schematic diagram shown below A(31:0)
• ALU should use the combinational logic to calculate an output based on the
four bit op-code input.
• ALU should pass the result to the out bus when enable line in high, and tri-state
the out bus when the enable line is low.
• ALU should decode the 4 bit op-code according to the given in example below.
5. Develop the Verilog code for the following flip-flops SR, D, JK &T.
6. Design 4 bit binary, BCD counters (Synchronous reset and asynchronous reset) and “any
sequence” counters using Verilog code.
PART - B
2. Write HDL code to interface Hex key pad and display the key code on seven segment display.
4. Write HDL code to accept 8 channel analog signal, Temperature sensors and display the data on
LC panel or seven segment display
5. Write HDL code to generate different waveforms (Sine, Square, Triangle, Ramp etc.,) using DAC
change the frequency and amplitude.
CYCLES OFEXPERIMENTS:
CYCLE EXPERIMENTS
1 1. Logic gates
2. Half adder
3. Full adder-3Descriptions
4. Gray to binary Conversion
2 1. 2 to 4decoder
2. 8 to 3 (encoder without priority & with priority)
3. 8 to 1 Multiplexer
5. De-Multiplexer
6. Comparator
7. ALU
3 1. SR, D, JK & T Flip flop
2. 4-bit Binary counter
3. BCD counters
4. Mod –n Counter
(Synchronous reset and asynchronous reset) and “any sequence” counters
4 1. Stepper Motor
2. DC Motor
3. Seven segment Display
4. Elevator
5. DAC
2.1 HDL
In electronics, a hardware description language or HDL is any language from a class of
Computer languages for formal description of electronic circuits. It can describe the circuit's
operation, its design and organization, and tests to verify its operation by means of simulation
HDLs are standard text-based expressions of the spatial, temporal structure and behavior of
electronic systems. In contrast to a software programming language, HDL syntax, semantics
include explicit notations for expressing time and concurrency, which are the attributes of
hardware. Languages whose only characteristic is to express circuit connectivity between
hierarchies of blocks are properly classified as net-list languages.
HDLs are used to write executable specifications of some piece of hardware. A simulation
program, designed to implement the underlying semantics of the language statements,
coupled with simulating the progress of time, provides the hardware designer with the
ability to model a piece of hardware before it is created physically. It’s this execute ability
that gives HDLs the illusion of being programming languages. Simulators capable of supporting
discrete-event and continuous-time (analog) modeling exist, and HDLs targeted for each are
available.
It is certainly possible to represent hardware semantics using traditional programming languages
such as C++, although to function such programs must be augmented with extensive and
unwieldy class libraries. Primarily, however, software programming languages function as a
hardware description language
Using the proper subset of virtually any language, a software program called a
synthesizer can infer hardware logic operations from the language statements and produce an
equivalent net-list of generic hardware primitives to implement the specified behavior. This
typically requires the synthesizer to ignore the expression of any timing constructs in the text.
The two most widely-used and well-supported HDL varieties used in industry are
VHDL (VHSICHDL)
Verilog
2.2 VHDL
VHDL (Very High Speed Integrated Circuit Hardware Description Language) is
commonly used as a design-entry language for field-programmable gate arrays and application-
specific integrated circuits in electronic design automation of digital circuits.
VHDL is a fairly general-purpose language, and it doesn’t require a simulator on which to run
the code. There are a lot of VHDL compilers, which build executable binaries. It can read and
write files on the host computer, so a VHDL program can be written that generates another
VHDL program to be incorporated in the design being developed. Because of this general-
purpose nature, it is possible to use VHDL to write a test bench that verifies with the user, and
compares results with those expected. This is similar to the capabilities of the Verilog language
VHDL is not a case sensitive language. One can design hardware in a VHDL IDE (such as
Xilinx or Quartus) to produce the RTL schematic of the desired circuit. After that, the
generated schematic can be verified using simulation software (such as Model-Sim) which
shows the waveforms of inputs and outputs of the circuit after generating the appropriate
test bench. To generate an appropriate test bench for a particular circuit or VHDL code,
the inputs have to be defined correctly. For example, for clock input, a loop process or an
iterative statement is required.
The key advantage of VHDL when used for systems design is that it allows the behavior of the
required system to be described (modeled) and verified (simulated) before synthesis tools
translate the design into real hardware (gates and wires). When a VHDL model is translated
into the "gates and wires" that are mapped onto a programmable logic device such as a CPLD
or FPGA, then it is the actual hardware being configured, rather than the VHDL code
being "executed" as if on some form of a processor chip.
Both VHDL and Verilog emerged as the dominant HDLs in the electronics industry while older
and less-capable HDLs gradually disappeared from use. But VHDL and Verilog share many of
the same limitations: neither HDL is suitable for analog/mixed-signal circuit simulation. Neither
possesses language constructs to describe recursively-generated logic structures
2.3 Verilog
Verilog is a hardware description language (HDL) used to model electronic systems. The
language supports the design, verification, and implementation of analog, digital, and mixed -
signal circuits at various levels of abstraction
The designers of Verilog wanted a language with syntax similar to the C programming language
so that it would be familiar to engineers and readily accepted. The language is case- sensitive,
has a preprocessor like C, and the major control flow keywords, such as "if" and "while",
are similar. The formatting mechanism in the printing routines and language operators and their
precedence are also similar
The language differs in some fundamental ways. Verilog uses Begin/End instead of curly braces
to define a block of code. The concept of time, so important to a HDL won't be found in C The
language differs from a conventional programming language in that the execution of statements
is not strictly sequential. A Verilog design consists of a hierarchy of modules are defined
with a set of input, output, and bidirectional ports. Internally, a module contains a list of wires
and registers. Concurrent and sequential statements define the behavior of the module by
defining the relationships between the ports, wires, and registers Sequential statements are
placed inside a begin/end block and executed in sequential order within the block. But all
concurrent statements and all begin/end blocks in the design are executed in parallel,
qualifying Verilog as a Dataflow language. A module can also contain one or more instances
of another module to define sub-behavior
A subset of statements in the language is synthesizable. If the modules in a design contains a
netlist that describes the basic components and connections to be implemented in hardware only
synthesizable statements, software can be used to transform or synthesize the design into the net
list may then be transformed into, for example, a form describing the standard cells of an
integrated circuit (e.g. ASIC) or a bit stream for a programmable logic device (e.g. FPGA).
Describing a design
In VHDL an entity is used to describe a hardware module
An entity can be described using,
1. Entity declaration
2. Architecture.
1. Entity declaration
It defines the names, input output signals and modes of a hardware module
Syntax
Entity entity _ name is
port declaration
end entity name
An entity declaration should start with “entity” and ends with “end” keywords. Ports are
interfaces through which an entity can communicate with its environment. Each port must have a
name, direction and a type. An entity may have no port declaration also. The direction will be
input, output or in-out.
2. Architecture:
It describes the internal description of design or it tells what is there inside design
each entity has at least one architecture and an entity can have many architectures.
Architecture can be described using structural, dataflow, behavioral or mixed style.
Syntax:
architecture architecture_name of entity_name is
architecture_declarative_part;
begin
statements;
endarchitecture_name;
Here we should specify the entity name for which we are writing the architecture body. The
architecture statements should be inside the begin and end keyword. Architecture declarative part
may contain variables, constants, or component declaration.
The internal working of an entity can be defined using different modeling styles inside
architecture body. They are
Structure of an entity:
Program
Here STD_LOGIC_1164 is an IEEE standard which defines a nine-value logic type, called
STD_ULOGIC. Use is a keyword, which imports all the declarations from this package. The
architecture body consists of concurrent signal assignments, which describes the functionality of
the design. Whenever there is a change in RHS, the expression is evaluated and the value is
assigned to LHS.
Behavioral modeling:
In this style of modeling, the internal working of an entity can be implemented using set of
statements.
It contains:
Process
statements
Sequential statements
Signal assignment statements
SEACET Dept. of ECE
10
HDL LAB MANUAL 15ECL58
Process statement is the primary mechanism used to model the behavior of an entity it
contains sequential statements, variable assignment (:=) statements or signal assignment
(<=) statements etc. It may or may not contain sensitivity list. If there is an event occurs on any
of the signals in the sensitivity list, the statements within the process are executed. Inside the
process the execution of statements will be sequential and if one entity is having two
processes the execution of these processes will be concurrent. At the end it waits for another
event tooccur.
Here whenever there is a change in the value of A OR B the process statements are executed.
Structural modeling
The implementation of an entity is done through set of interconnected components. It
contains
Signal declaration.
Component instances
Port maps.
Wait statements.
Component declaration:
Syntax:
Component Component_name
List_of_interface ports;
end component component_ name;
Before instantiating the component it should be declared using component declaration as
shown above. Component declaration declares the name of the entity and interface of a
component.
Consider the example of full adder using 2 half adder and 1 OR gate.
The program written for half adder in dataflow modeling is instantiated as shown above.
HA is the name of the entity in dataflow modeling. C1, C2, S1 are the signals used for internal
connections of the component which are declared using the keyword signal. Port map is used to
connectdifferentcomponentsaswellasconnectcomponentstoportsoftheentity.
Signal list is the architecture signals which will be connected to component ports. This can be
done in different ways. What is declared above is positional binding. One more type is the named
binding.
The above can be written as,
HA1: ha port map (A => A, B => B, S => S1, C => C1);
HA2: ha port map (A => S1, B => Cin, S=> SUM, C => C2);
Design verification is often the most time-consuming portion of the design process, due to
the disconnect between a device's functional specification, the designer's interpretation of the
specification, and the imprecision of the HDL language. The majority of the initial
test/debug cycle is conducted in the HDL simulator environment, as the early stage of the
design is subject to frequent and major circuit changes. An HDL description can also be
prototyped and tested in hardware–programmable logic devices are often used for this
purpose. Hardware prototyping is comparatively more expensive than HDL simulation, but
offers a real-world view of the design. Prototyping is the best way to check interfacing
against other hardware devices, and hardware prototypes, even those running on slow
FPGAs, offer much faster simulation times than pure HDL simulation.
Requirements:
1. HDL software with front-end (Design entry, synthesis, simulation implementation and
programming)
2. FPGA kit with minimum 400,000 gate density
Procedure:
Software part
1. Click on the Project navigator icon on the desktop of your PC. Write the vhdl code, check
syntax and perform the functional simulation using Model sim XE.
2. Open a new UCF file and lock the pins of the design with FPGAI/O pins.
3. Implementthedesignbydoubleclickingontheimplementationtoolselection
4. Check the implementation reports.
5. Create programming file.
FPGAs, alternative to the custom ICs, can be used to implement an entire System On one Chip
(SOC). The main advantage of FPGA is ability to reprogram. User can reprogram an FPGA to
implement a design and this is done after the FPGA is manufactured. This brings the name
“FieldProgrammable.”
Custom ICs are expensive and takes long time to design so they are useful when produced in
bulk amounts. But FPGAs are easy to implement within a short time with the help of Computer
Aided Designing (CAD) tools.
3.2 XILINXFPGA
Xilinx logic block consists of one Look Up Table (LUT) and one FlipFlop. An LUT is used to
implement number of different functionality. The input lines to the logic block go into the LUT
and enable it. The output of the LUT gives the result of the logic function that it implements and
the output of logic block is registered or unregistered output from the LUT.
Xilinx LUT
The ISE (Integrated Synthesis Environment) design flow comprises the following steps:
1. Design Entry
Create an ISE project as follows:
1. Create a project.
2. Create files and add them to your project, including a user constraints (UCF)file.
3. Add any existing files to your project.
Functional Verification
You can verify the functionality of your design at different points in the design flow as follows:
2. Design Synthesis
3. Design Implementation
Implement your design as follows:
2 76 IO 2 85 IO 2 102 IO
3 77 IO 3 86 IO 3
4 79 IO 4 87 IO 4 103 IO
5 78 IO 5 89 IO 5 105 IO
6 82 IO 6 90 IO 6 107 IO
7 80 IO 7 92 IO 7 108 IO
8 83 IO 8 96 IO 8 113 IO
1 112 IO 1 28 IO 1 57 IO
2 116 IO 2 31 IO 2 59 IO
3 119 IO 3 33 IO 3 63 IO
4 118 IO 4 44 IO 4 69 IO
5 123 IO 5 46 IO 5 68 IO
6 131 IO 6 47 IO 6 73 IO
7 130 IO 7 50 IO 7 70 IO
8 137 IO 8 51 IO 8 20 IO
1 1 IO 1 93 IO 1 60 IO
2 12 IO 2 95 IO 2 56 IO
3 13 IO 3 97 IO 3 41 IO
4 14 IO 4 98 IO 4 40 IO
5 15 IO 5 99 IO 5 36 IO
6 17 IO 6 194 IO 6 35 IO
7 18 IO 7 IO 7 32 IO
8 21 IO 8 122 IO 8 10 IO
9 23 IO 9 129 IO 9 11 IO
10 24 IO 10 132 IO 10 8 IO
11 26 IO 11 135 IO 11 7 IO
12 27 IO 12 140 IO 12 6 IO
13 5 13 5 13 5
14 -5 14 -5 14 -5
FRC9
1 5 IO
2 4 IO
3 2 IO
4 141 IO
5 NA IO
6 NA IO
7 NA IO
8 NA IO
9 VCC
POWER
10 GND SUPPLY
52
CLK
PROCEDURE:
The Procedure to be followed for Software and Hardware Programs are as follows:
Step 1: Go to Start Menu All Programs Xilinx ISE 9.1i and Select Project
Navigator.
Step 2: Go to File Menu and Close any previously opened project if any, and then Select
New
Project.
Step 3: Enter the Project name and location and Select the Top level module type as HDL.
Step 4: Select the Device family and Device name as Spartan3 and xc3s400, pin density
tq144,-4
for FPGA.
Step 5: Right click on the source file and select new source speed followed by VHDL module
and
Give the file name same as the name of the entity.
Step 6: Define the ports used and their respective directions in the next window that opens.
Step 7: Write the architecture body and the generics etc. in the incomplete VHDL code that
opensand save the file after completion of editing.
Step 8: Go to the Process view window and right click on the Synthesize - XST and Select
Run.
Correct the errors if any.
Step 9: Select and Right click the source file and click on the New Source tab and then select
the Test Bench Waveform and give the appropriate file name for the same.
Step 10: Make the alterations in the Clock information and initial length of the test bench
if
needed.
Step 11: Set or Reset the inputs as required and save the test bench waveform file.
Step 12: Go to Process view and under Xilinx ISE Simulator Right click on the Simulate
Behavioural model to see the output for the input conditions.
Step 13: Make the appropriate connections between the PC and the FPGA kit for the
observation
of outputs in the FPGA kit and for other Hardware Programming.
Step 14: Select and Right click the source file and click on the New Source tab and then
select
the Implementation Constraints file and give the appropriate file name for the same.
Step 15: Go to Process view and under User Constraints, double click on the Edit
Constraints
(Text).
Step 16: Write the code for the user constraints file as required and save the same.
Step 17: Select the main source file and right click on the Implement design in the process
view
window and select run.
Step 18: Right click on the Generate Programming file in the process view window and
select run.
SEACET Dept. of ECE
23
HDL LAB MANUAL 15ECL58
Step 19: Under the Generate Programming file tab, right click on the Configure
device
(Impact) and click on the Run option.
Step 20: Select the appropriate mode and make changes in the jumper settings of the FPGA
Kit
as required, select the appropriate .BIT extension file in the pop up window.
Step 21: Right click on the Chip picture in the pop up window and Select “Program”. Debug the
errors if it is there. Set the conditions for the inputs using Dip switch and observe the
outputs.
PART–A
EXPERIMENT NO. 1
AIM: WRITE HDL CODE TO REALIZE ALL LOGIC GATES
A logic gate performs a logical operation on one or more logic inputs and produces a
single logic output. The logic normally performed is Boolean logic and is most commonly
found in digital circuits
VERILOG CODE
module allgate ( a, b, yand,yor,ynot,ynand,ynor,yxor,yxnor );
input a,b;
output yand, yor, ynot, ynand, ynor, yxor, yxnor;
UCF FILE:
EXPERIMENT NO.2
AIM: Write HDL codes for the following combinational circuits.
2 a) 2 TO 4 DECODER
RTL SCHEMATIC
Truth Table
EN Din(1) Din(0) Dout(3) Dout(2) Dout(1) Dout(0)
1 x x 0 0 0 0
0 0 0 0 0 0 1
0 0 1 0 0 1 0
0 1 0 0 1 0 0
0 1 1 1 0 0 0
RTL Schematic
Truth Table
INPUTS OUTPUTS
en Din(0) Din(1) Din(2) Din(3) Din(4) Din(5) Din(6) Din(7) Dout(0) Dout(1) Dout(3)
1 x x x x x x x X z z z
0 0 0 0 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 1 0 1 1 0
0 0 0 0 0 0 1 0 0 1 0 1
0 0 0 0 0 1 0 0 0 1 0 0
0 0 0 0 1 0 0 0 0 0 1 1
0 0 0 1 0 0 0 0 0 0 1 0
0 0 1 0 0 0 0 0 0 0 0 1
0 1 0 0 0 0 0 0 0 0 0 0
VERILOG CODE
module WPencode(en,Din,Dout);
inputen;
input [ 7 : 0 ] Din;
output [ 2 : 0 ] Dout;
reg [ 2 : 0 ] Dout;
always@(en,Din)
begin
if(en == 1)
begin
Dout = 3’bZZZ;
end
else
begin
Case (Din)
8’b00000001:Dout = 3’b000;
8’b00000010:Dout = 3’b001;
8’b00000100:Dout = 3’b010;
8’b00001000:Dout = 3’b011;
8’b00010000:Dout = 3’b100;
8’b00100000:Dout = 3’b101;
8’b01000000:Dout = 3’b110;
8’b01000000:Dout = 3’b111;
endcase
end
end
endmodule
RTL Schematic
Truth Table
INPUTS OUTPUTS
en Din(0) Din(1) Din(2) Din(3) Din(4) Din(5) Din(6) Din(7) Dout(0) Dout(1) Dout(3)
0 x x x x x x x x z z z
1 x x x x x x x 1 1 1 1
1 x x x x x x 1 0 1 1 0
1 x x x x x 1 0 0 1 0 1
1 x x x x 1 0 0 0 1 0 0
1 x x x 1 0 0 0 0 0 1 1
1 x x 1 0 0 0 0 0 0 1 0
1 x 1 0 0 0 0 0 0 0 0 1
1 1 0 0 0 0 0 0 0 0 0 0
VERILOG CODE
module priori (en,Din,Dout);
input en;
input [ 7 : 0 ] Din;
output [ 2 : 0 ] Dout;
reg [ 2 : 0 ] Dout;
always@(en,Din)
begin
if(en == 1) // Active high enable
begin
Dout = 3'bZZZ; // Initializing Dout to high Impedance
end
else
Begin
casex(Din)
8'b00000001 :Dout = 3'b000;
8'b0000001X :Dout = 3'b001;
8'b000001XX :Dout = 3'b010;
Design a 3 bit priority encoder. The input I is 3-bit and the output P is 3-bit.
I (0) when high, has the highest priority, followed by I (1) and I (2).The output P
for highest Priority to lowest is 0, 1 and 2 (decimal). Respectively Construct the
truth table, minimize and write both VHDL and Verilog codes.
2 d) 8 TO 1 MULTIPLEXER
Truth Table:
VERILOG CODE
module mux8_1(S,I,Y);
input [2:0]S;
input[7:0];
output Y;
reg Y;
always@(S,I)
Begin
case(S)
3'b000:Y=I[0];
3'b001:Y=I[1];
3'b010:Y=I[2];
3'b011:Y=I[3];
3'b100:Y=I[4];
3'b101:Y=I[5];
3'b110:Y=I[6];
3'b111:Y=I[7];
Endcase
End
Endmodule
RESULTS:
RTL Schematic
VERILOG CODE
module bin2gray(b,g);
input [3:0] b;
output [3:0] g;
assign g[3]=b[3];
assign g[2]=b[3]^b[2];
assign g[1]=b[2]^b[1];
assign g[0]=b[1]^b[0];
Endmodule
Design a 4-bit parity generator .The output is 0 for even parity and 1 for odd parity
Write both the VHDL and Verilog codes
2 f) 4-BIT COMPARATOR
Truth Table
VERILOG CODE
module comp(a,b,aeqb,agtb,altb); input [3:0] a,b;
output aeqb,agtb,altb; reg aeqb,agtb,altb; always @(a ,b)
begin
aeqb=0; agtb=0;altb=0;
if(a==b) //checking for equality condition
aeqb=1;
else if (a>b) // checking greater than condition
agtb=1;
else altb=1;
end
endmodule
RTL Schematic
Truth Table
DATA FLOW
BEHAVIORAL STYLE
VHDLCODE VERILOG CODE
library IEEE; module fulladd(a,b,cin,sum,cout);
use IEEE.STD_LOGIC_1164.ALL; input a,b,cin;
use IEEE.STD_LOGIC_ARITH.ALL; output sum,cout;
use IEEE.STD_LOGIC_UNSIGNED.ALL; reg sum,cout;
always@(a,b,cin)
entity fulladder_beh is begin
Port ( a,b,cin : in std_logic; sum,cout : out std_logic); case ({a,b,cin}) // Concatenating (a,b,cin)
end fulladder_beh; 3'b000:{cout,sum}=2'b00;
3'b001:{cout,sum}=2'b01;
architecture Behavioral of fulladder_beh is 3'b010:{cout,sum}=2'b01;
signal abcin:std_logic_vector(2 downto 0); 3'b011:{cout,sum}=2'b10;
Begin 3'b100:{cout,sum}=2'b01;
abcin<=a&b&cin; -- Concatenating (a,b,cin) 3'b101:{cout,sum}=2'b10;
process( abcin) 3'b110:{cout,sum}=2'b10;
Begin 3'b111:{cout,sum}=2'b11;
case abcin is endcase
when”000”=>sum<=’0;cout<=’0’; end
when”001”=>sum<=’1;cout<=’0’; endmodule
when”010”=>sum<=’1;cout<=’0’;
when”011”=>sum<=’0;cout<=’1’;
when”100”=>sum<=’1;cout<=’0’;
when”101”=>sum<=’0;cout<=’1’;
when”110”=>sum<=’0;cout<=’1’;
STRUCTURAL MODELLING
VHDLCODE VERILOG CODE
---HALF ADDER
library IEEE; //HALF ADDER
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL; module ha(x,y,s,c);
use IEEE.STD_LOGIC_UNSIGNED.ALL; input x,y;
output s,c;
assign s = x^y;
entity halfadd is assign c = x & y;
Port ( x,y :in STD_LOGIC; endmodule
s,c : outSTD_LOGIC);
end halfadd;
//FULL ADDER
architecture Behavioral of halfadd is module fulladder(a,b,cin,sum,cout);
begin input a, b,cin;
s <= x xor y;---xor operation c output sum, cout;
<= x and y; ---and operation wire temp1,temp2,temp3;
end Behavioral; ha L1(a,b,temp1,temp2); // L1 & L2 are modules
---FULL ADDER ha L2(temp1,cin,sum,temp3);
library IEEE; assign cout= temp2 | temp3; // or operation
use IEEE.STD_LOGIC_1164.ALL; endmodule
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity fulladd is
Port ( A,B,Cin : in STD_LOGIC;
Sum,Cout : outSTD_LOGIC);
end fulladd;
AIM: Write a model for 4/8/32 bit Arithmetic Logic Unit using the schematic
diagram shown below.
RTL Schematic
VERILOG CODE
module ALU ( a, b, opcode, y );
input [3:0]a, b;
input [2:0]opcode;
output [7:0]y;
reg [7:0]y;
always@( a, b)
begin
case opcode
3’d0: y=a+b;
3’d1: y=a-b;
3’d2: y={4’ d0, (a | b)};
3’d3: y={4’ d0, (a & b)};
3’d4: y={4’ d0, ~a};
3’d5: y=a*b;
3’d6: y={4’ d0, ~(a & b)};
3’d7: y={4’ d0, (a ^ b)};
default: begin end
endcase
end
endmodule
output cout;
input[2:0] opcode;
output [31:0]zout;
reg [31:0]zout;
reg [32:0]temp;
reg cout;
always@( a, b)
begin
case(opcode)
4'b0001: temp = a + b;
4'b0010: temp = a - b;
4'b0011: temp[31:0]= ~a;
4'b0100: temp= a[15:0]* b[15:0];
4'b0101: temp[31:0]= a & b;
4'b0110: temp[31:0]= a | b;
4'b0111: temp[31:0]= ~(a & b);
4'b1000: temp[31:0]= a ^ b;
default : temp= 8'bZ;
endcase
zout=temp[31:0]; cout=temp[32];
temp[32]=0;
end
end
endmodule
EXPERIMENT NO.5
AIM: Develop the HDL code for the following flip-flop: T, D, SR and JK.
RTLSchematic TruthTable
CLK T Q Qb OPERATION
0 x Q Qb No Change
1 0 Q Qb No Change
1 1 Qb Q Toggle
RTL Schematic
Truth Table
CLK D Q Qb OPERATION
0 x Q Qb No change
1 0 0 1 Reset
1 1 1 0 Set
VERILOG CODE
module dff(d,clk,q,qb);
input d,clk;
output q,qb;
reg q=0,qb=1;
always@(posedge clk)
begin
q= d;
end
qb=~q;
endmodule
RTL Schematic
Truth Table
CLK
s r Q Qb
0 x x Q Qb
1 0 1 0 1
1 1 0 1 0
1 1 1 Not defined
1 0 0 Q Qb
VERILOG CODE
module sr(sr,clk,q,qb);
input clk;
input[1:0]sr;
output q,qb;
reg q=0,qb=1;
always@(posedge clk)
begin
case(sr)
2'b00:q=q;
2'b01:q=0;
2'b10:q=1;
2'b11:q=1'bZ;
endcase
qb=~q;
End
endmodule
RTLSchematic TruthTable
CLK J K Q Qb
0 x x Q Qb
1 0 1 0 1
1 1 0 1 0
1 1 1 Qb Q
1 0 0 Q Qb
EXPERIMENT-6
RTLSchematic TruthTable
1 0 0110 0111
1 0 0111 1000
1 0 1000 1001
1 0 1001 1010
1 0 1010 1011
1 0 1011 1100
1 0 1100 1101
1 0 1101 1110
1 0 1110 1111
VERILOG CODE
module syncnt(clk,reset,count);
input clk,reset;
output [3:0] count;
reg[3:0]count=4'b0000;
reg[24:0] clkd;
always@(posedge clk)
Begin
clkd = clkd+1;
End
always @(posedge clkd[20])
Begin
if(reset==1)
count = 4'b0000;
SEACET Dept. of ECE
52
HDL LAB MANUAL 15ECL58
Else
count = count+1;
End
Endmodule
Write HDL code to describe 4-bit even counter with active low clear.
RTL Schematic
VERILOG CODE
module asyncnt(clk,reset,count);
input clk,reset;
output [3:0] count;
reg[3:0]count=4'b0;
reg[24:0] clkd;
always@(posedge clk)
Begin
clkd = clkd+1;
End
always @(posedge clkd[20] or posedge reset)
Begin
if(reset==1)
count = 4'b0000;
Else
count = count+1;
End
endmodule
Design a counter, which counts 0, 2, 3, 5, 7, 0.write the HDL code for the same.
[Use JK Flip Flop
1. Write HDL code to generate different waveforms (saw tooth, sine wave,
square, triangle, ramp etc.) using DAC change the frequency and
amplitude.
a)DAC-SQUAREWAVE:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL; use
IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity squarewg is
Port ( clk,rst : in std_logic;
dac : out std_logic_vector(0 to 7));
end squarewg;
process(temp(3))
begin
if rst='1' then
cnt<="00000000";
elsif rising_edge (temp(3)) then if
cnt< 255 and en='0' then
cnt<=cnt+1;
en<='0';
dac<="00000000";
elsif cnt=0 then
en<='0';
else en<='1';
cnt<=cnt-1;
b)DAC-TRIANGLEWAVE:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use
IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity triangwg is
Port ( clk,rst : in
std_logic;
dac : out std_logic_vector(0 to
7)); end triangwg;
cnt<=cnt+1;
if cnt(0)='1' then
dac<=cnt(1 to 8);
else
dac<= not(cnt( 1 to 8));
end if;
end if;
end process;
end Behavioral;
c)DAC-RAMPWAVE:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity rampwg is
Port ( clk,rst : in std_logic;
dac : out std_logic_vector(0 to 7));
end rampwg;
d)DAC-SINEWAVE:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity sinewave is
Port (clk:in std_logic;
dout : out std_logic_vector(0 downto 7));
end sinewave;
begin
if (clk'event and clk='1')then
a<=a+1;
if (r='1') then
if (a=1) then
dout <=sinedata(b);
b<=b+1;
a<=1;
end if;
if (b=48) then
r<='0';
end if;
elsif (r='0') then
if (a=1) then
dout <= sinedata(b);
b<=b-1;
a<=1;
end if;
if (b=1) then
r<='1';
end if; end if; end if;
end process;
end behavioral;
n=24 ---- 00 h
n=23 ---- 01 h
n=22 ---- 02 h
:
n=2 ---- 6Fh
n=1 ---- 77 h
n=0 ---- 7F h corresponds to127.5
n=1 ---- 87 h
n=2 ---- 8F h
n=3 ---- 97 h
:
n=24 ---- FEh
n=25 ---- FF h corresponds to255
2. SEVEN SEGMENTDISPLAY:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity ssg is
Port ( keyreturn : in STD_LOGIC_VECTOR (3 downto 0);
keyscan : buffer STD_LOGIC_VECTOR (3 downto 0):="1000";
segm : out STD_LOGIC_VECTOR (3 downto 0);
clk : inSTD_LOGIC;
dis : out STD_LOGIC_VECTOR (6 downto 0):="0000000");
end ssg;
"0110011","1011011","1011111","1110000",
SEACET Dept. of ECE
64
HDL LAB MANUAL 15ECL58
"1111111","1111011","1110111","0011111",
"1001110","0111101","1001111","1000111");
begin
dis<=segdis(a);
segm<="1110";---To activate one segment out of four segments
end process;
end Behavioral;
Display a b c d e f g
0 1 1 1 1 1 1 0
1 0 1 1 0 0 0 0
2 1 1 0 1 1 0 1
3 1 1 1 1 0 0 1
4 0 1 1 0 0 1 1
5 1 0 1 1 0 1 1
6 1 0 1 1 1 1 1
7 1 1 1 0 0 0 0
8 1 1 1 1 1 1 1
9 1 1 1 1 0 1 1
A 1 1 1 0 1 1 1
B 0 0 1 1 1 1 1
C 1 0 0 1 1 1 0
D 0 1 1 1 1 0 1
E 1 0 0 1 1 1 1
F 1 0 0 0 1 1 1
3. ELEVATOR
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity ssg is
Port ( keyreturn : in STD_LOGIC_VECTOR (3 downto 0);
keyscan : buffer STD_LOGIC_VECTOR (3 downto 0):="1000";
segm : out STD_LOGIC_VECTOR (3 downto 0);
clk : inSTD_LOGIC;
dis : out STD_LOGIC_VECTOR (6 downto 0):="0000000");
end ssg;
Process(clk,a,temp)
begin
if(clk'event and clk='1')then
b<=b+1;
if(b=2000000)then ------Delay between one floor to next floor
if(temp<a) then -------a=current floor and temp= destination floor
temp<=temp+1 ;
b<=0;
elsif(temp/=a) then
temp<=temp-1 ;
b<=0;
end if;
end if;
end if;
end process;
process(temp) ---- when the key of destination floor is pressed process will be activated
type sevseg is array (0 to 15 )of std_logic_vector(6 downto 0);
constantsegdis:sevseg:= ( "1111110","0110000","1101101","1111001",
"0110011","1011011","1011111","1110000",
"1111111","1111011","1110111","0011111",
"1001110","0111101","1001111","1000111");
begin
dis<=segdis(temp);
segm<="1110";
end process;
end Behavioral;
4. DC MOTOR:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity dcmotor is
Port ( clk : in STD_LOGIC;
reset,dir : inSTD_LOGIC;
pwm : out STD_LOGIC_VECTOR (1 downto 0);
rly : out STD_LOGIC;
row : in STD_LOGIC_VECTOR (3 downto 0));
end dcmotor;
ddclk<=div_reg(12);
tick<=row(0)and row(1)and row(2)and row(3);
process(tick)
begin
if falling_edge(tick)then
case row is
when "1110"=> dcycle<=255;---speed highest
when "1101"=> dcycle<=200;
when "1011"=> dcycle<=150;
when "0111"=> dcycle<=100;---speed lowest
when others=> dcycle<=100;
end case;
end if;
end process;
process(ddclk,reset)
begin
if reset='0'then
counter<="00000000";
pwm<="01";
elsif(ddclk'event and ddclk='1')then
counter<=counter+1;
if(counter >=dcycle)then
pwm(1)<='0';
else
pwm(1)<='1';
end if;
end if;
end process;
rly<=dir;
end Behavioral;
5. STEPPER MOTOR:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity steppermt is
Port ( clk,dir,rst : in std_logic;
dout : out std_logic_vector(3 downto 0));
end steppermt;
end Behavioral;
When current is passed through the coil, the circular magnetic field is generated.