hdl manual 2012 4th sem 10esl48

CITY ENGINEERING COLLEGE

HDL LAB MANUAL 4TH SEM ELECTONICS AND COMMUNICATION

S K LAKSHMI NARAYAN

R C VISHVAKIRAN

ELECTRONICS AND COMMUNICATION ENGG DEPT.

Doddakallasandra, Off Kanakapura Road, Bangalore - 560061

2 0 1 2

10ESL 48

i

CONTENTS PART A: PROGRAMMING (using VHDL and Verilog)

1. Write HDL code to realize all the logic gates ................................................................................ 1 2. Write a HDL program for the following combinational designs ............................................... 3-16

a. 2 to 4 decoder ............................................................................................................................ 3 b. 8 to 3 (encoder without priority & with priority) .................................................................. 5,7 c. 8 to 1 multiplexer ..................................................................................................................... 9 d. 4 bit binary to gray converter ................................................................................................. 11 e. De-multiplexer, comparator .............................................................................................. 13,15

3. Write a HDL code to describe the functions of a Full Adder Using 3 modeling styles .......... 17-21 a. Full Adder Data Flow Description ......................................................................................... 17 b. Full Adder Behavioral Description ........................................................................................ 18 c. Full Adder Structural Description .......................................................................................... 20

4. Write a model for 32 bit ALU using the schematic diagram shown below A (31:0) B (31:0) ................................................................................................... 22 • ALU should use 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.

OPCODE ALU OPERATION

1. A + B

2. A – B

3. A Complement

4. A AND B

5. A OR B

6. A NAND B

7. A XOR B

5. Develop the HDL code for the following flip-flops, SR, JK, D, T ......................................... 24-31 a. SR Flip Flop ........................................................................................................................... 24 b. JK Flip Flop ............................................................................................................................ 26 c. D Flip Flop ............................................................................................................................. 28 d. T Flip Flop .............................................................................................................................. 30

6. Design 4 bit binary, BCD counters (Synchronous reset and Asynchronous reset) and “any sequence” counters .................................................................................................... 32-40 a. Binary Synchronous Reset 4bit Counter ................................................................................ 32 b. Binary Asynchronous Reset 4bit Counter .............................................................................. 33 c. BCD Synchronous Reset 4bit Counter ................................................................................... 35 d. BCD Asynchronous Reset 4bit Counter ................................................................................. 37 e. Binary Any Sequence up down 4bit Counter ......................................................................... 39

OPCODE

ENABLE

ALU OPERATION

ii

PART B: INTERFACING (at least four of the following must be covered using VHDL/Verilog)

1. Write HDL code to display messages on the given seven segment display and LCD and accepting Hex keypad input data .............................................................................................................. 41-47 a. 7 Segment Display ................................................................................................................. 41 b. LCD Display .......................................................................................................................... 45

2. Write HDL code to control speed, direction of DC and Stepper motor .................................. 48-53 a. Stepper Motor ......................................................................................................................... 48 b. DC Motor ............................................................................................................................... 51

3. Write HDL code to control external lights using relays. .............................................................. 54 4. Write HDL code to generate different waveforms (Sine, Square, Triangle,

Ramp etc.,) using DAC change the frequency and amplitude ............................................... 56-66 a. Sine Wave .............................................................................................................................. 57 b. Square Wave .......................................................................................................................... 59 c. Triangle Wave ........................................................................................................................ 61 d. Positive Ramp ........................................................................................................................ 63 e. Negative Ramp ....................................................................................................................... 65

Web link: http://www.scribd.com/doc/49031100

4TH SEM, HDL MANUAL, 10ESL48 2012 E&C DEPT., CEC, BANGALORE

PART-A: NON-INTERFACING 1 SKLN,RCVK

1. ALL LOGIC GATES

a_in

not_op

and_op

nand_op

or_op

nor_op

xor_op

xnor_op

b_in

Logic Diagram of All Gates

Inputs Outputs

a_in b_in not_op (a_in) and_op nand_op or_op nor_op xor_op xnor_op

0 0 1 0 1 0 1 0 1 0 1 1 0 1 1 0 1 0 1 0 0 0 1 1 0 1 0 1 1 0 1 0 1 0 0 1

Truth Table 1: All Logic Gates

VHDL File Name: AlllogicGates.vhd -- All Logic Gates - DataFlow library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity AllLogicGates is port ( a_in : in STD_LOGIC; b_in : in STD_LOGIC; not_op : out STD_LOGIC; and_op : out STD_LOGIC; nand_op : out STD_LOGIC; or_op : out STD_LOGIC; nor_op : out STD_LOGIC; xor_op : out STD_LOGIC; xnor_op : out STD_LOGIC); end AllLogicGates;

ALLLOGICGATES

a_in

b_in

not_opand_opnand_op

or_opnor_opxor_opxnor_op

Figure 1: Block Diagram of All Logic Gates

inputs outputs



architecture DataFlow of AllLogicGates is begin not_op <= not a_in; and_op <= a_in and b_in; nand_op <= a_in nand b_in; or_op <= a_in or b_in; nor_op <= a_in nor b_in; xor_op <= a_in xor b_in; xnor_op <= a_in xnor b_in; end DataFlow;

Verilog File Name: AlllogicGates.v // All Logic Gates module AllLogicGates( a_in, b_in, not_op, and_op, nand_op, or_op, nor_op, xor_op, xnor_op ); input a_in, b_in; output not_op, and_op, nand_op, or_op, nor_op, xor_op, xnor_op; assign not_op = ~(a_in); assign and_op = a_in & b_in; assign nand_op = ~(a_in & b_in); assign or_op = a_in | b_in; assign nor_op = ~(a_in | b_in); assign xor_op = a_in ^ b_in; assign xnor_op = ~(a_in ^ b_in); endmodule



2. Decoder 2 to 4

Decoder 2 to 4

d_in

en

d_op

Figure 2: Block Diagram of Decoder 2 to 4

inputs

outputs

2

4

Inputs Outputs en d_in(1) d_in(0) d_op(3) d_op(2) d_op(1) d_op(0) 1 X X Z Z Z Z 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

Truth Table 2: Decoder 2 to 4

VHDL File Name: decoder2to4.vhd -- decoder2to4 - Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity decoder2to4 is Port ( d_in : in STD_LOGIC_VECTOR (1 downto 0); en : in STD_LOGIC; d_op : out STD_LOGIC_VECTOR (3 downto 0)); end decoder2to4; architecture Behavioral of decoder2to4 is begin process(en,d_in) begin if(en/='0')then -- Active Low Enabled d_op<="ZZZZ"; else case d_in is when "00" => d_op <= "0001"; when "01" => d_op <= "0010"; when "10" => d_op <= "0100"; when "11" => d_op <= "1000"; when others => d_op <= "ZZZZ"; end case; end if; end process; end Behavioral;



Verilog File Name: decoder2to4.v // decoder2to4 module decoder2to4( d_in, en, d_op ); input [1:0] d_in; input en; output [3:0] d_op; wire en; wire [1:0] d_in; reg [3:0] d_op; always @ (en, d_in) begin if(en) // Active Low Enabled d_op = 4'bZZZZ; else begin case (d_in) 2'b00 : d_op = 4'b0001; 2'b01 : d_op = 4'b0010; 2'b10 : d_op = 4'b0100; 2'b11 : d_op = 4'b1000; default : d_op = 4'bZZZZ; endcase end end endmodule



3. Encoder Without Priority

EncoderWithout Priority

a_in

en

y_op

Figure 3: Block Diagram of Encoder Without Priority

inputs

outputs

8

3

Inputs Outputs

en a_in(7) a_in(6) a_in(5) a_in(4) a_in(3) a_in(2) a_in(1) a_in(0) y_op (2)

y_op (1)

y_op (0)

1 X X X X X X X X Z Z Z

0 0 0 0 0 0 0 0 1 0 0 0

0 0 0 0 0 0 0 1 0 0 0 1

0 0 0 0 0 0 1 0 0 0 1 0

0 0 0 0 0 1 0 0 0 0 1 1

0 0 0 0 1 0 0 0 0 1 0 0

0 0 0 1 0 0 0 0 0 1 0 1

0 0 1 0 0 0 0 0 0 1 1 0

0 1 0 0 0 0 0 0 0 1 1 1

Truth Table 3: Encoder Without Priority

VHDL File Name: encd_wo_prior.vhd -- encoder without priority - Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity encd_wo_prior is Port ( en : in STD_LOGIC; a_in : in STD_LOGIC_VECTOR (7 downto 0); y_op : out STD_LOGIC_VECTOR (2 downto 0)); end encd_wo_prior;



architecture Behavioral of encd_wo_prior is begin process (en,a_in) begin if(en /= '0') then -- Active Low Enabled y_op <= "ZZZ"; else case a_in is when "00000001" => y_op <= "000"; when "00000010" => y_op <= "001"; when "00000100" => y_op <= "010"; when "00001000" => y_op <= "011"; when "00010000" => y_op <= "100"; when "00100000" => y_op <= "101"; when "01000000" => y_op <= "110"; when "10000000" => y_op <= "111"; when others => y_op <= "ZZZ"; end case; end if; end process; end Behavioral;

Verilog File Name: encd_wo_prior.v // encoder without priority module encd_wo_prior( en, a_in, y_op ); input en; input [7:0] a_in; output [2:0] y_op; wire en; wire [7:0] a_in; reg [2:0] y_op; always @ (a_in, en) begin if(en) //Active Low Enabled y_op = 3'bZZZ; else begin case (a_in) 8'b00000001 : y_op = 3'b000; 8'b00000010 : y_op = 3'b001; 8'b00000100 : y_op = 3'b010; 8'b00001000 : y_op = 3'b011; 8'b00010000 : y_op = 3'b100; 8'b00100000 : y_op = 3'b101; 8'b01000000 : y_op = 3'b110; 8'b10000000 : y_op = 3'b111; default : y_op = 3'bZZZ; endcase end end endmodule



4. Encoder With Priority

EncoderWith Priority

a_in

en

y_op

Figure 4: Block Diagram of Encoder With Priority

inputs

outputs

8

3

Inputs Outputs

en a_in(7) a_in(6) a_in(5) a_in(4) a_in(3) a_in(2) a_in(1) a_in (0)

y_op (2)

y_op (1)

y_op (0)

1 X X X X X X X X Z Z Z

0 1 X X X X X X X 1 1 1

0 0 1 X X X X X X 1 1 0

0 0 0 1 X X X X X 1 0 1

0 0 0 0 1 X X X X 1 0 0

0 0 0 0 0 1 X X X 0 1 1

0 0 0 0 0 0 1 X X 0 1 0

0 0 0 0 0 0 0 1 X 0 0 1

0 0 0 0 0 0 0 0 1 0 0 0 Truth Table 4: Encoder With Priority

VHDL File Name: encd_w_prior.vhd -- encd_w_prior - Dataflow library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity encd_w_prior is Port ( en : in STD_LOGIC; a_in : in STD_LOGIC_VECTOR (7 downto 0); y_op : out STD_LOGIC_VECTOR (2 downto 0)); end encd_w_prior;



architecture Dataflow of encd_w_prior is begin y_op <= "ZZZ" when en = '1' else -- Active Low Enabled "111" when a_in(7)='1' else "110" when a_in(6)='1' else "101" when a_in(5)='1' else "100" when a_in(4)='1' else "011" when a_in(3)='1' else "010" when a_in(2)='1' else "001" when a_in(1)='1' else "000" when a_in(0)='1' else "ZZZ"; end Dataflow;

Verilog File Name: encd_w_prior.v // encoder with priority module encd_w_prior( en, a_in, y_op ); input en; input [7:0] a_in; output [2:0] y_op; wire en; wire [7:0] a_in; reg [2:0] y_op; always @ (a_in, en) begin if (en == 1'b1) // Active Low Enabled y_op = 3'bZZZ; else begin if(a_in[7] == 1'b1) y_op = 3'b111; else if(a_in[6] == 1'b1) y_op = 3'b110; else if(a_in[5] == 1'b1) y_op = 3'b101; else if(a_in[4] == 1'b1) y_op = 3'b100; else if(a_in[3] == 1'b1) y_op = 3'b011; else if(a_in[2] == 1'b1) y_op = 3'b010; else if(a_in[1] == 1'b1) y_op = 3'b001; else if(a_in[0] == 1'b1) y_op = 3'b000; else y_op = 3'bZZZ; end end endmodule



5. Multiplexer 8 to 1

Multiplexer 8 to 1

i_in

en

y_out

Figure 5: Block Diagram of Multiplexer 8 to 1

inputs

output

8

sel 3

Inputs Output

en sel (2)

sel (1)

sel (0)

i_in (7)

i_in (6)

i_in (5)

i_in (4)

i_in (3)

i_in (2)

i_in (1)

i_in (0) y_out

1 X X X X X X X X X X X Z 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 1 1 0 0 0 0 1 0 0 0 1 0 1 0 0 0 0 0 1 0 0 0 0 1 0 1 0 1 0 0 1 0 0 0 0 0 1 0 1 1 0 0 1 0 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 0 1

Truth Table 5: Mux 8 to 1

VHDL File Name: mux8to1.vhd --mux8to1 - Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity mux8to1 is Port ( en : in STD_LOGIC; sel : in STD_LOGIC_VECTOR (2 downto 0); i_in : in STD_LOGIC_VECTOR (7 downto 0); y_out : out STD_LOGIC); end mux8to1; architecture Behavioral of mux8to1 is begin process(en,sel,i_in) begin



if( en /= '0') then -- Active Low Enabled y_out <= 'Z'; else case sel is when "000" => y_out <= i_in(0); when "001" => y_out <= i_in(1); when "010" => y_out <= i_in(2); when "011" => y_out <= i_in(3); when "100" => y_out <= i_in(4); when "101" => y_out <= i_in(5); when "110" => y_out <= i_in(6); when "111" => y_out <= i_in(7); when others => y_out <= 'Z'; end case; end if; end process; end Behavioral;

Verilog File Name: mux8to1.v // Multiplexer 8 to 1 module mux8to1(en,i_in,sel,y_out); input en; input [2:0] sel; input [7:0] i_in; output y_out; wire en; wire [7:0] i_in; wire [2:0] sel; reg y_out; always@(en,sel,i_in) begin if(en != 0) // Active Low Enabled y_out = 1'bZ; else begin case(sel) 3'b000: y_out = i_in[0]; 3'b001: y_out = i_in[1]; 3'b010: y_out = i_in[2]; 3'b011: y_out = i_in[3]; 3'b100: y_out = i_in[4]; 3'b101: y_out = i_in[5]; 3'b110: y_out = i_in[6]; 3'b111: y_out = i_in[7]; default: y_out = 1'bZ; endcase end end endmodule



6. 4Bit Binary to Gray Converter

Binary to

GrayConverter

b_ing_op

Figure 6: Block Diagram of Binary to Gray Converter

inputs

outputs4 4

Logic Diagram of 4bits Binary to Gray Converter

b_in(0)g_op(0)

b_in(1)

b_in(2)

b_in(3)

g_op(1)

g_op(2)

g_op(3)

Boolean Expressions g_op(3) = b_in(3) g_op(2) = b_in(3) ⨁ b_in(2) g_op(1) = b_in(2) ⨁ b_in(1) g_op(0) = b_in(1) ⨁ b_in(0)

Inputs Outputs

Decimal Binary Gray b_in(3) b_in(2) b_in(1) b_in(0) g_op(3) g_op(2) g_op(1) g_op(0)

0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 2 0 0 1 0 0 0 1 1 3 0 0 1 1 0 0 1 0 4 0 1 0 0 0 1 1 0 5 0 1 0 1 0 1 1 1 6 0 1 1 0 0 1 0 1 7 0 1 1 1 0 1 0 0 8 1 0 0 0 1 1 0 0 9 1 0 0 1 1 1 0 1

10 1 0 1 0 1 1 1 1 11 1 0 1 1 1 1 1 0 12 1 1 0 0 1 0 1 0 13 1 1 0 1 1 0 1 1 14 1 1 1 0 1 0 0 1 15 1 1 1 1 1 0 0 0

Truth Table 6: Binary to Gray



VHDL File Name: bin_to_gray_4bit.vhd -- Binary to Gray 4 bit converter - Dataflow library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity bin_to_gray_4bit is Port ( b_in : in STD_LOGIC_VECTOR (3 downto 0); g_op : out STD_LOGIC_VECTOR (3 downto 0)); end bin_to_gray_4bit; architecture Dataflow of bin_to_gray_4bit is begin g_op(3) <= b_in(3); g_op(2) <= b_in(3) xor b_in(2); g_op(1) <= b_in(2) xor b_in(1); g_op(0) <= b_in(1) xor b_in(0); end Dataflow;

Verilog File Name: bin_to_gray_4bit.v // Binary to Gray 4bit Converter module bin_to_gray_4bit( b_in, g_op ); input [3:0] b_in; output [3:0] g_op; wire [3:0] b_in; reg [3:0] g_op; always @ (b_in) begin g_op[3] = b_in[3]; g_op[2] = b_in[3] ^ b_in[2]; g_op[1] = b_in[2] ^ b_in[1]; g_op[0] = b_in[1] ^ b_in[0]; end endmodule



7. Demultiplexer 1 to 4

Demultiplexer 1 to 4sel

en

Figure 7: Block Diagram of Demultiplexer 1 to 4

inputs2 y_out

outputs

4

a_in

Inputs Outputs en sel (1) sel (0) a_in y_out (3) y_out (2) y_out (1) y_out (0) 1 X X X Z Z Z Z 0 0 0 1 0 0 0 1 0 0 1 1 0 0 1 0 0 1 0 1 0 1 0 0 0 1 1 1 1 0 0 0

Truth Table 7: Demux 1 to 4

VHDL File Name: demux1to4.vhd -- Demux1to4 - Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity demux1to4 is Port ( en : in STD_LOGIC; sel : in STD_LOGIC_VECTOR(1 downto 0); a_in : in STD_LOGIC; y_out : out STD_LOGIC_VECTOR (3 downto 0)); end demux1to4; architecture Behavioral of demux1to4 is begin process(en,sel,a_in) begin if(en /= '0') then -- Active Low Enabled y_out <= "ZZZZ"; else y_out <= "0000"; case sel is when "00" => y_out(0) <= a_in; when "01" => y_out(1) <= a_in; when "10" => y_out(2) <= a_in; when "11" => y_out(3) <= a_in; when others => y_out <= "ZZZZ"; end case; end if; end process; end Behavioral;



Verilog File Name: demux1to4.v // Demultiplexer 1 to 4 module demux1to4(en,sel,a_in,y_out); input en; input [1:0] sel; input a_in; output [3:0] y_out; wire en; wire [1:0] sel; wire a_in; reg [3:0] y_out; always@(en,sel,a_in) begin if(en != 0) // Active Low Enabled y_out = 4'bZZZZ; else begin y_out = 4'b0000; case(sel) 2'b00 : y_out[0] = a_in; 2'b01 : y_out[1] = a_in; 2'b10 : y_out[2] = a_in; 2'b11 : y_out[3] = a_in; default : y_out = 4'bZZZZ; endcase end end endmodule



8. 4Bit Comparator

Comparator 4bit

b_in

g_op

Figure 8: Block Diagram of Comparator 4bit

inputsoutputs

4

a_in 4

L_op

e_op

Inputs Outputs

a_in > b_in a_in = b_in a_in < b_in a_in b_in g_op e_op L_op

---- ---- Z Z Z

1100 0011 1 0 0

0110 0110 0 1 0

1000 1110 0 0 1 Truth Table 8: Comparator 4Bits

VHDL File Name: comparator4bit.vhd --Comparator4bit - Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity comparator4bit is Port ( a_in : in STD_LOGIC_VECTOR (3 downto 0); b_in : in STD_LOGIC_VECTOR (3 downto 0); g_op : out STD_LOGIC; e_op : out STD_LOGIC; L_op : out STD_LOGIC); end comparator4bit; architecture Behavioral of comparator4bit is begin process(a_in,b_in) begin if( a_in > b_in) then g_op <= '1'; e_op <= '0'; L_op <= '0'; elsif(a_in = b_in) then g_op <= '0'; e_op <= '1'; L_op <= '0'; elsif(a_in < b_in) then g_op <= '0'; e_op <= '0'; L_op <= '1';



else g_op <= 'Z'; e_op <= 'Z'; L_op <= 'Z'; end if; end process; end Behavioral;

Verilog File Name: comparator4bit.v // Comparator 4bit module comparator4bit( a_in,b_in,g_op,L_op,e_op); input [3:0] a_in,b_in; output g_op,L_op,e_op; wire [3:0] a_in,b_in; reg g_op,L_op,e_op; always@(a_in,b_in) if( a_in > b_in) begin g_op = 1; L_op = 0; e_op = 0; end else if( a_in < b_in) begin g_op = 0; L_op = 1; e_op = 0; end else if( a_in == b_in) begin g_op = 0; L_op = 0; e_op = 1; end else begin g_op = 1'bZ; L_op = 1'bZ; e_op = 1'bZ; end endmodule



9. Full Adder

Full Adder

sum

Figure 9: Block Diagram of Full Adder

inputs outputs

carry

a_in

b_in

c_in

Logic Diagram of Full Adder

a_inb_in sum

c_in

carry

x1x2

a2

a1 o1

S1

S2

S3

Inputs Outputs a_in b_in c_in sum carry

0 0 0 0 0

0 0 1 1 0

0 1 0 1 0

0 1 1 0 1

1 0 0 1 0

1 0 1 0 1

1 1 0 0 1

1 1 1 1 1 Truth Table 9: Full Adder

Full Adder Data Flow Description

VHDL File Name: FullAdder_DF.vhd -- FullAdder_DF - Data_Flow library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity FullAdder_DF is Port ( a_in, b_in, c_in : in STD_LOGIC; sum, carry : out STD_LOGIC); end FullAdder_DF;



architecture Data_Flow of FullAdder_DF is begin sum <= a_in xor b_in xor c_in; carry <= (a_in and b_in) or (b_in and c_in) or (a_in and c_in); end Data_Flow;

Verilog File Name: FullAdder_DF.v // FullAdder - Data Flow Model module FullAdder_DF( a_in, b_in, c_in, sum, carry ); input a_in, b_in, c_in; output sum, carry; assign sum = a_in ^ b_in ^ c_in; assign carry = (a_in & b_in) | (b_in & c_in) | (c_in & a_in); endmodule Full Adder Behavioral Description

VHDL File Name: FullAdder_Behav.vhd -- Full Adder - Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity FullAdder_Behav is Port ( a_in, b_in, c_in : in STD_LOGIC; sum, carry : out STD_LOGIC); end FullAdder_Behav; architecture Behavioral of FullAdder_Behav is begin process ( a_in, b_in, c_in) begin if(a_in='0' and b_in='0' and c_in = '0') then sum <= '0';carry <= '0'; elsif (( a_in='0' and b_in='0' and c_in = '1') or (a_in='0' and b_in='1' and c_in = '0') or (a_in='1' and b_in='0' and c_in = '0')) then sum <= '1';carry <= '0'; elsif (( a_in='0' and b_in='1' and c_in = '1') or (a_in='1' and b_in='0' and c_in = '1') or (a_in='1' and b_in='1' and c_in = '0')) then sum <= '0';carry <= '1'; elsif(a_in='1' and b_in='1' and c_in = '1') then sum <= '1';carry <= '1'; end if; end process; end Behavioral;



Verilog File Name: FullAdder_Behav.v //FullAdder - Behavioral Model module FullAdder_Behav( a_in, b_in, c_in, sum, carry ); input a_in, b_in, c_in; output sum, carry; wire a_in, b_in, c_in; reg sum, carry; always @ ( a_in, b_in, c_in) begin if(a_in==0 & b_in==0 & c_in==0) begin sum = 0; carry = 0; end else if (( a_in==0 & b_in==0 & c_in == 1) | (a_in==0 & b_in==1 & c_in == 0) | (a_in==1 & b_in==0 & c_in == 0)) begin sum = 1; carry = 0; end else if (( a_in==0 & b_in==1 & c_in == 1) | (a_in==1 & b_in==0 & c_in == 1) | (a_in==1 & b_in==1 & c_in == 0)) begin sum = 0; carry = 1; end else if(a_in==1 & b_in==1 & c_in == 1) begin sum = 1; carry = 1; end end endmodule



Full Adder Structural Description

VHDL File Name: full_adder_struct.vhd -- Full Adder - Structural library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity full_adder is port ( a_in, b_in, c_in : in STD_LOGIC; sum,carry : out STD_LOGIC); end full_adder; architecture structural of full_adder is component xor2_1 port( a, b : in STD_LOGIC; y : out STD_LOGIC); end component; component and2_1 port( a, b : in STD_LOGIC; y : out STD_LOGIC); end component; component or2_1 port( a, b : in STD_LOGIC; y : out STD_LOGIC); end component; signal s1,s2,s3: STD_LOGIC; begin x1: xor2_1 port map (a_in, b_in, s1); a1: and2_1 port map (a_in, b_in, s2); x2: xor2_1 port map (s1, c_in, sum); a2: and2_1 port map (s1, c_in, s3); o1: or2_1 port map (s2, s3, carry); end structural; VHDL File Name: xor2_1.vhd -- xor2_1 - DataFlow library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity xor2_1 is Port ( a,b : in STD_LOGIC; y : out STD_LOGIC); end xor2_1; architecture data_flow of xor2_1 is begin y <= a xor b; end data_flow;



VHDL File Name: and2_1.vhd -- and2_1 - DataFlow library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity and2_1 is port ( a, b : in STD_LOGIC; y : out STD_LOGIC); end and2_1; architecture data_flow of and2_1 is begin y <= a and b; end data_flow; VHDL File Name: or2_1.vhd -- or2_1 - DataFlow library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity or2_1 is Port ( a,b : in STD_LOGIC; y : out STD_LOGIC); end or2_1; architecture data_flow of or2_1 is begin y <= a or b; end data_flow;

Verilog File Name: full_adder_struct.v //Full Adder - Structural module full_adder( a_in, b_in, c_in, sum, carry ); input a_in, b_in, c_in; output sum, carry; wire s1,s2,s3; //syntax: gate_operator lable (ouput, input, input); xor x1 (s1, a_in, b_in); and a1 (s2, a_in, b_in); xor x2 (sum, s1, c_in); and a2 (s3, s1, c_in); or o1 (carry, s2, s3); endmodule



10. ALU 32 Bits

ALU 32bitsa_in

b_in

y_op

Figure 10: Block Diagram of ALU 32bits

inputsoutputs

opc 4

32

32

32

en

Inputs Outputs Actions

en opc a_in b_in y_op

0 XXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ No Change

1 0001 01100000000000000111111111111111 01000000000000000111111110011001 10100000000000001111111110011000 a_in + b_in

1 0010 01100000000000000111111111111111 01000000000000000111111110011001 00100000000000000000000001100110 a_in - b_in

1 0011 01100000000000000111111111111111 01000000000000000111111110011001 10011111111111111000000000000000 not a_in

1 0100 01100000000000000111111111111111 01000000000000000111111110011001 01000000000000000111111110011001 a_in and b_in

1 0101 01100000000000000111111111111111 01000000000000000111111110011001 01100000000000000111111111111111 a_in or b_in

1 0110 01100000000000000111111111111111 01000000000000000111111110011001 10111111111111111000000001100110 a_in nand b_in

1 0111 01100000000000000111111111111111 01000000000000000111111110011001 00100000000000000000000001100110 a_in xor b_in

Truth Table 10: ALU 32bits

VHDL File Name: alu32bit.vhd --ALU32bit – Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity alu32bit is Port ( en : in BIT; opc : in STD_LOGIC_VECTOR (3 downto 0); a_in, b_in : in STD_LOGIC_VECTOR (31 downto 0); y_op : out STD_LOGIC_VECTOR (31 downto 0)); end alu32bit;



architecture Behavioral of alu32bit is begin process(en, a_in, b_in, opc) begin if (en = '1') then -- Active High Enabled case opc is when "0001" => y_op <= a_in + b_in; when "0010" => y_op <= a_in - b_in; when "0011" => y_op <= not a_in; when "0100" => y_op <= a_in and b_in; when "0101" => y_op <= a_in or b_in; when "0110" => y_op <= a_in nand b_in; when "0111" => y_op <= a_in xor b_in; when others => null; end case; else y_op <= "ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ"; end if; end process; end behavioral;

Verilog File Name: alu32bit.v // ALU 32bit module alu32bit( en, opc, a_in, b_in, y_op ); input en; input [3:0] opc; input [31:0] a_in, b_in; output [31:0] y_op; wire en; wire [3:0] opc; wire [31:0] a_in, b_in; reg [31:0] y_op; always @ ( en, opc, a_in, b_in) if (en == 1) // Active High Enabled case (opc) 4'b0001 : y_op = a_in + b_in; 4'b0010 : y_op = a_in - b_in; 4'b0011 : y_op = ~ a_in; 4'b0100 : y_op = a_in & b_in; 4'b0101 : y_op = a_in | b_in; 4'b0110 : y_op = ~ (a_in & b_in); 4'b0111 : y_op = a_in ^ b_in; default null; endcase else y_op = 32'bZ; endmodule



11. S R Flip Flop

SR Flip Flop

rstqb

Figure 11: Block Diagram of SR Flip Flop

inputs

clk

s

q

outputsr

Inputs Outputs

rst clk s r q qb Action

1 ↑ X X q qb No Change

0 ↑ 0 0 q qb No Change

0 ↑ 0 1 0 1 Reset

0 ↑ 1 0 1 0 Set

0 ↑ 1 1 - - Illegal Truth Table 11: S R Flip Flop

VHDL File Name: sr_ff.vhd -- S R Flip Flop library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity sr_ff is Port ( s,r,rst,clk : in STD_LOGIC;

q,qb : out STD_LOGIC); end sr_ff; architecture Behavioral of sr_ff is signal temp : std_logic := '0'; begin process(clk,rst) begin if(rst = '1') then temp <= '0';



elsif (clk'event and clk = '1') then if(s = '0' and r ='0') then temp <= temp; elsif(s = '0' and r ='1') then temp <= '0'; elsif(s = '1' and r ='0') then temp <= '1'; elsif(s = '1' and r ='1') then temp <= 'X'; end if; end if; end process; q <= temp; qb <= not temp; end Behavioral;

Verilog File Name: sr_ff.v //Async SR Flip Flop module sr_ff( sr , clk , reset , q ,qb ); input [1:0] sr; input clk, reset ; output q,qb; reg q,qb; always @ ( posedge clk or posedge reset) if (reset) begin q = 1'b0; qb = ~q; end else begin case (sr) 2'd0 : q = q; 2'd1 : q = 1'b0; 2'd2 : q = 1'b1; 2'd3 : q = 1'bX; endcase qb = ~q; end endmodule



12. J K Flip Flop

JK Flip Flop

rstqb

Figure 12: Block Diagram of JK Flip Flop

inputs

clk

j

q

outputsk

Inputs Outputs rst clk j k q qb Action 1 ↑ X X q qb No Change 0 ↑ 0 0 q qb No Change 0 ↑ 0 1 0 1 Reset 0 ↑ 1 0 1 0 Set 0 ↑ 1 1 q' q' Toggle

Truth Table 12: J K Flip Flop

VHDL File Name: jk_ff.vhd --JK Flip Flop library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity jk_ff is Port ( j,k,rst,clk : in STD_LOGIC; q,qb : out STD_LOGIC); end jk_ff; architecture Behavioral of jk_ff is signal temp : std_logic := '0'; begin process(clk,rst) begin if(rst = '1') then temp <= '0'; elsif(clk'event and clk = '1') then if(j = '0' and k ='0') then temp <= temp; elsif(j = '0' and k ='1') then temp <= '0'; elsif(j = '1' and k ='0') then temp <= '1'; elsif(j = '1' and k ='1') then temp <= not temp; end if; end if; end process; q <= temp; qb <= not temp; end Behavioral;



Verilog File Name: jk_ff.v //Async JK Flip Flop module jk_ff( jk , clk , reset , q ,qb ); input [1:0] jk; input clk, reset ; output q,qb; reg q,qb; always @ ( posedge clk or posedge reset) if (reset) begin q = 1'b0; qb = ~q; end else begin case (jk) 2'd0 : q = q; 2'd1 : q = 1'b0; 2'd2 : q = 1'b1; 2'd3 : q = ~q; endcase qb = ~q; end endmodule



13. D Flip Flop

D Flip Flop

rstqb

Figure 13: Block Diagram of D Flip Flop

inputs

clk

d q

outputs

Inputs Outputs

rst clk d q qb Action

1 ↑ X q qb No Change

0 ↑ 0 0 1 Reset

0 ↑ 1 1 0 Set Truth Table 13: D Flip Flop

VHDL File Name: d_ff.vhd -- D Flip Flop library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity d_ff is Port ( d,clk,rst : in STD_LOGIC; q,qb : out STD_LOGIC); end d_ff; architecture Behavioral of d_ff is signal temp : std_logic := '0'; begin process(clk,rst) begin if(rst = '1') then temp <= '0'; elsif(clk'event and clk = '1') then temp <= d; end if; end process; q <= temp; qb <= not temp; end Behavioral;



Verilog File Name: d_ff.v //Async D Flip Flop module d_ff( d , clk , reset , q ,qb ); input d, clk, reset ; output q,qb; reg q,qb; always @ ( posedge clk or posedge reset) if (reset) begin q = 1'b0; qb=~q; end else begin q = d; qb=~q; end endmodule



14. T Flip Flop

T Flip Flop

rstqb

Figure 14: Block Diagram of T Flip Flop

inputs

clk

t q

outputs

Inputs Outputs

rst clk t q qb Action

1 ↑ X q qb No Change

0 ↑ 0 q qb No Change

0 ↑ 1 q' q' Toggle Truth Table 14: T Flip Flop

VHDL File Name: t_ff.vhd --T Flip Flop library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity t_ff is Port ( t,clk,rst : in STD_LOGIC; q,qb : out STD_LOGIC); end t_ff; architecture Behavioral of t_ff is signal temp : std_logic := '0'; begin process(clk,rst) begin if(rst = '1') then temp <= '0'; elsif(clk'event and clk = '1' and t = '1') then temp <= not temp; end if; end process; q <= temp; qb <= not temp; end Behavioral;



Verilog File Name: t_ff.v //Async T Flip Flop module t_ff( t, clk, reset, q, qb ); input t, clk, reset ; output q,qb; reg q,qb; always @ ( posedge clk or posedge reset) if (reset) begin q = 1'b0; qb=~q; end else if (t) begin q = ~q; qb = ~q; end endmodule



15. Binary Synchronous Reset 4bit Counter

Binary Synchronous Reset 4bit Counterrst

Figure 15: Block Diagram of Binary Synchronous Reset 4bit Counter

inputs

clk

bin_outoutputs

4

VHDL File Name: bin_counter_sync_4bit.vhd -- Binary Synchronous reset 4bit counter library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity bin_counter_sync_4bit is Port ( clk,rst : in STD_LOGIC; bin_out : out STD_LOGIC_VECTOR (3 downto 0)); end bin_counter_sync_4bit; architecture Behavioral of bin_counter_sync_4bit is signal temp: std_logic_vector(3 downto 0); begin process(clk) begin if ( clk'event and clk='1') then if(rst = '1') then temp <= "0000"; else temp <= temp+'1'; end if; end if; end process; bin_out <= temp ; end Behavioral;

Verilog File Name: bin_counter_sync_4bit.v // Binary synchronous reset 4bit counter module bin_sync_4bit ( rst, clk, count); input rst,clk; output [3:0] count; reg [3:0] count; initial begin count = 4'b0000; end always @(posedge clk) if(rst) count = 4'b0000; else count = count + 4'b0001; endmodule



16. Binary Asynchronous Reset 4bit Counter

Binary Asynchronous Reset 4bit Counterrst

Figure 16: Block Diagram of Binary Asynchronous Reset 4bit Counter

inputs

clk

bin_outoutputs

4

VHDL File Name: bin_counter_async_4bit.vhd --Binary Asynchronous reset 4bit counter library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity bin_counter_async_4bit is Port ( clk,rst : in STD_LOGIC; bin_out : out STD_LOGIC_VECTOR (3 downto 0)); end bin_counter_async_4bit; architecture Behavioral of bin_counter_async_4bit is signal temp: std_logic_vector(3 downto 0); begin process(clk,rst) begin if(rst = '1') then temp <= "0000"; elsif ( clk'event and clk='1') then temp <= temp+'1'; end if; end process; bin_out <= temp ; end Behavioral;



Verilog File Name: bin_counter_async_4bit.v // Binary asynchronous reset 4bit counter module bin_async_4bit ( rst, clk, count); input rst,clk; output [3:0] count; reg [3:0] count; initial begin count = 4'b0000; end always @(posedge clk or posedge rst) if(rst) count = 4'b0000; else count = count + 4'b0001; endmodule



17. BCD Synchronous Reset 4bit Counter

BCD Synchronous Reset 4bit Counterrst

Figure 17: Block Diagram of BCD Synchronous Reset 4bit Counter

inputs

clk

bcd_outoutputs

4

VHDL File Name: bcd_counter_sync_4bit.vhd --BCD Synchronous reset 4bit counter library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity bcd_counter_sync is Port ( clk,rst : in STD_LOGIC; bcd_out : out STD_LOGIC_VECTOR (3 downto 0)); end bcd_counter_sync; architecture Behavioral of bcd_counter_sync is signal temp: std_logic_vector(3 downto 0); begin process(clk) begin if ( clk'event and clk='1') then if(rst = '1' or temp = "1001") then temp <= "0000"; else temp <= temp+'1'; end if; end if; end process; bcd_out <= temp ; end Behavioral;



Verilog File Name: bcd_counter_sync_4bit.v // BCD synchronous reset 4bit counter module bcd_sync ( rst, clk, count); input rst,clk; output [3:0] count; reg [3:0] count; initial begin count = 4'd0; end always @(posedge clk) if(rst) count = 4'd0; else if(count < 4'd9 ) count = count + 4'd1; else count = 4'd0; endmodule



18. BCD Asynchronous Reset 4bit Counter

BCD Asynchronous Reset 4bit Counterrst

Figure 18: Block Diagram of BCD Asynchronous Reset 4bit Counter

inputs

clk

bcd_outoutputs

4

VHDL File Name: bcd_counter_async_4bit.vhd -- BCD asynchronous reset 4bit counter library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity bcd_counter_async is Port ( clk,rst : in STD_LOGIC; bcd_out : out STD_LOGIC_VECTOR (3 downto 0)); end bcd_counter_async; architecture Behavioral of bcd_counter_async is signal temp: std_logic_vector(3 downto 0):= "0000"; begin process(clk,rst) begin if(rst = '1' or temp = "1010") then temp <= "0000"; elsif ( clk'event and clk='1') then temp <= temp+'1'; end if; end process; bcd_out <= temp ; end Behavioral;



Verilog File Name: bcd_counter_async_4bit.v // BCD asynchronous reset 4bit counter module bcd_async ( rst, clk, count); input rst,clk; output [3:0] count; reg [3:0] count; initial begin count = 4'd0; end always @(posedge clk or posedge rst) if(rst) count = 4'd0; else if(count < 4'd9 ) count = count + 4'd1; else count = 4'd0; endmodule



19. Binary Any Sequence up down 4bit Counter

Binary Any Sequence4bit Counterupdown

Figure 19: Block Diagram of Binary Any Sequence 4bit Counter

inputs

clk

bin_outoutputs

4

rst

d_inload

4

VHDL File Name: bin_counter_any_seq_4bit.vhd -- Binary Any Sequence up down 4bit counter library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity bin_counter_any_seq is Port ( clk,rst,load,updown : in STD_LOGIC; d_in :in STD_LOGIC_VECTOR( 3 downto 0); bin_out : out STD_LOGIC_VECTOR (3 downto 0)); end bin_counter_any_seq; architecture Behavioral of bin_counter_any_seq is signal temp: std_logic_vector(3 downto 0):= "0000"; begin process(clk, rst) begin if(rst = '1') then temp <= "0000"; elsif(load = '1') then temp <= d_in; elsif ( clk'event and clk='1' and load = '0') then if ( updown = '1') then temp <= temp+'1'; else temp <= temp-'1'; end if; end if; end process; bin_out <= temp ; end Behavioral;



Verilog File Name: bin_counter_any_seq_4bit.v // Binary Any Sequence Up Down Counter module any_seq_bin ( rst,load, clk,din,updown, count); input rst,clk,updown,load; input [3:0] din; output [3:0] count; reg [3:0] count; always @(posedge clk) if(rst) count = 4'b0000; else if(load) count = din; else if (updown) count = count + 4'b0001; else count = count - 4'b0001; endmodule


PART-B: INTERFACING 41 SKLN,RCVK

1. 7 Segment to Accept Hex Keypad

0 1 2 34 5 6 78 9 A BC D E F

7 Segment

(Comman Cathode)

BUS/STRIP CABLE

Keypad

CPLDXC9572

JTAG

Power

Supply

PC

CPLD Board

J2J6

Mega KBDSP1

Figure 1: Interface Diagram of CPLD Board and MEGA KBDSP1

7 Segment Display to accept Hex

Keypad Input Datainputs

clk

key_scoutputs

4key_rl 4

digit6

seg_out7

Figure 2: Block diagram of 7Segment Display to accept Hex Keypad Input Data



VHDL File Name: keypad_led_display.vhd --keypad_led_display.vhd -- keypad_led_display - Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity keypad_led_display is Port ( clk : in STD_LOGIC;

key_rl : in BIT_VECTOR (3 downto 0); key_sc : out BIT_VECTOR (3 downto 0); digit : out STD_LOGIC_VECTOR (5 downto 0); seg_out : out STD_LOGIC_VECTOR (6 downto 0));

end keypad_led_display; architecture Behavioral of keypad_led_display is

signal clk_div:std_logic_vector(12 downto 0); -- 2 msec delay, 4Mhz clock source / 8 KHz = 500Hz -- ( = 2 msec) signal key_sc_temp :bit_vector(3 downto 0):="0001"; -- 2 ^ 13 = 8KHz, 12 downto 0

begin digit <= "111110"; --active low enable process(clk) begin

if(clk'event and clk = '1') then clk_div <= clk_div + '1';

end if; end process; process(clk_div(12)) begin

if (clk_div(12)'event and clk_div(12) = '1') then key_sc_temp <= key_sc_temp rol 1;

end if; key_sc <= key_sc_temp;

end process;



process(key_rl,clk_div(12)) begin

if (clk_div(12)'event and clk_div(12) = '1') then --gfedcba if (key_sc_temp="0001" and key_rl="0001") then seg_out <= "0111111"; --0 elsif (key_sc_temp="0001" and key_rl="0010") then seg_out <= "0000110"; --1 elsif (key_sc_temp="0001" and key_rl="0100") then seg_out <= "1011011"; --2 elsif (key_sc_temp="0001" and key_rl="1000") then seg_out <= "1001111"; --3 elsif (key_sc_temp="0010" and key_rl="0001") then seg_out <= "1100110"; --4 elsif (key_sc_temp="0010" and key_rl="0010") then seg_out <= "1101101"; --5 elsif (key_sc_temp="0010" and key_rl="0100") then seg_out <= "1111101"; --6 elsif (key_sc_temp="0010" and key_rl="1000") then seg_out <= "0000111"; --7 elsif (key_sc_temp="0100" and key_rl="0001") then seg_out <= "1111111"; --8 elsif (key_sc_temp="0100" and key_rl="0010") then seg_out <= "1101111"; --9 elsif (key_sc_temp="0100" and key_rl="0100") then seg_out <= "1110111"; --A elsif (key_sc_temp="0100" and key_rl="1000") then seg_out <= "1111100"; --b elsif (key_sc_temp="1000" and key_rl="0001") then seg_out <= "0111001"; --C elsif (key_sc_temp="1000" and key_rl="0010") then seg_out <= "1011110"; --D elsif (key_sc_temp="1000" and key_rl="0100") then seg_out <= "1111001"; --E elsif (key_sc_temp="1000" and key_rl="1000") then seg_out <= "1110001"; --F end if;

end if; end process;

end Behavioral;



UCF File Name: keypad_led_display.ucf #keypad_led_display.ucf NET "clk" LOC = "p9" ; NET "digit<0>" LOC = "p68" ; NET "digit<1>" LOC = "p67" ; NET "digit<2>" LOC = "p66" ; NET "digit<3>" LOC = "p65" ; NET "digit<4>" LOC = "p63" ; NET "digit<5>" LOC = "p62" ; NET "key_rl<0>" LOC = "p1" ; NET "key_rl<1>" LOC = "p84" ; NET "key_rl<2>" LOC = "p83" ; NET "key_rl<3>" LOC = "p82" ; NET "key_sc<0>" LOC = "p5" ; NET "key_sc<1>" LOC = "p4" ; NET "key_sc<2>" LOC = "p3" ; NET "key_sc<3>" LOC = "p2" ; NET "seg_out<0>" LOC = "p81" ; NET "seg_out<1>" LOC = "p80" ; NET "seg_out<2>" LOC = "p79" ; NET "seg_out<3>" LOC = "p75" ; NET "seg_out<4>" LOC = "p72" ; NET "seg_out<5>" LOC = "p71" ; NET "seg_out<6>" LOC = "p70" ;



2. LCD Message Display

0 1 2 34 5 6 78 9 A BC D E F

LCD Display

BUS/STRIP CABLE

Keypad

CPLDXC9572

JTAG

Power

Supply

PC

CPLD Board

J2J6

Mega KBDSP1

ELECTRONICS

Figure 3: Interface Diagram of CPLD Board and MEGA KBDSP1

LCD

input

clk

dataoutputs

8

rd_wr

en

reg_sel

Figure 4: Block Diagram of LCD



VHDL File Name: lcd_message.vhd -- lcd_message.vhd -- LCD_message – Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity lcd_message is Port ( clk : in std_logic; data : out std_logic_vector(7 downto 0); reg_sel : out std_logic; rd_wr : out std_logic; en : out std_logic); end lcd_message; architecture Behavioral of lcd_message is

signal clkdiv : std_logic_vector(21 downto 0); signal dispclk : std_logic;

begin process(clk) begin

if( rising_edge(clk)) then clkdiv <= clkdiv + 1;

end if; dispclk <= clkdiv(15); en <= clkdiv(15);

end process; process(dispclk)

variable a : integer range 0 to 14:=0 ; type lcd_type is array (natural range <>) of std_logic_vector ( 7 downto 0); constant lcd_data : lcd_type( 0 to 14):=("00111000","00001110","00000110","00000001", "01000101","01001100","01000101","01000011","01010100","01010010","01001111","01001110", "01001001","01000011","01010011");



begin

rd_wr <= '0'; if(rising_edge(dispclk))then

if(a < 4) then reg_sel <= '0';

else reg_sel <= '1';

end if; data <= lcd_data(a); a := a + 1; if( a = 15) then

a := 3; end if;


end Behavioral; UCF File Name: LCD_message.ucf #LCD_message.ucf NET "clk" LOC = "p9" ; NET "data<0>" LOC = "p81" ; NET "data<1>" LOC = "p80" ; NET "data<2>" LOC = "p79" ; NET "data<3>" LOC = "p75" ; NET "data<4>" LOC = "p72" ; NET "data<5>" LOC = "p71" ; NET "data<6>" LOC = "p70" ; NET "data<7>" LOC = "p69" ; NET "en" LOC = "p66" ; NET "rd_wr" LOC = "p67" ; NET "reg_sel" LOC = "p68" ;



3. Stepper Motor Speed and Direction Control

BUS/STRIP CABLECPLD

XC9572

JTAG

Power

Supply

PC

CPLD Board

J3J6

Stepper/DC Motor Interface Card

KEY1 KEY2 KEY3 KEY4

RELAY1 RELAY2

J4To

Stepper Motor

KEY1

Direction Control

Figure 5: Interface Diagram of CPLD Board and Stepper Motor Interface Card

STEPPER MOTORinputs

clk_4M

d_out

outputs

4C_A

Figure 6: Block Diagram of Stepper Motor

Direction Control

1KEY



VHDL File Name: stepper_motor.vhd --stepper_motor.vhd -- stepper_motor – Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity stepper_motor is Port ( d_out : out std_logic_vector(3 downto 0);

C_A : in std_logic; clk_4M: in std_logic);

end stepper_motor; architecture Behavioral of stepper_motor is

signal clk_div: std_logic_vector ( 21 downto 0 ); signal clk_Hz: std_logic; type step_type is array (natural range <>) of std_logic_vector ( 3 downto 0); constant step_aclk : step_type( 0 to 3):=("0110","1010","1001","0101"); constant step_clk : step_type( 0 to 3):=("0101","1001","1010","0110");

begin

process(clk_4M) begin

if rising_edge(clk_4M) then clk_div <= clk_div + 1;

end if; clk_Hz <= clk_div(18); end process; process(clk_Hz) variable a : integer range 0 to 3:=0; begin



if rising_edge(clk_Hz) then

if (C_A = '1') then d_out <= step_clk(a);

else d_out <= step_aclk(a);

end if; a := a + 1; end if;

end process; end Behavioral; UCF File Name: stepper_motor.ucf #stepper_motor.ucf NET "C_A" LOC = "p79" ; NET "clk_4M" LOC = "p9" ; NET "d_out<0>" LOC = "p3" ; NET "d_out<1>" LOC = "p2" ; NET "d_out<2>" LOC = "p1" ; NET "d_out<3>" LOC = "p84" ;



4. DC Motor Speed and Direction Control

BUS/STRIP CABLECPLD

XC9572

JTAG

Power

Supply

PC

CPLD Board

J3J6

Stepper/DC Motor Interface Card

KEY1 KEY2 KEY3 KEY4

RELAY1 RELAY2

J5ToDC

Motor

Figure 7: Interface Diagram of CPLD Board and DC Motor Interface Card

DC MOTORinputs

clk

cloutputs

spd_cnt 4

acl

Figure 8: Block Diagram of DC Motor



VHDL File Name: dcmotor.vhd -- dcmotor.vhd -- DC motor – Behavioral 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; spd_cnt : in STD_LOGIC_vector(3 downto 0); cl : out STD_LOGIC; acl : out STD_LOGIC); end dcmotor; architecture Behavioral of dcmotor is

signal clk_div : std_logic_vector(21 downto 0); begin

process(clk) begin

if(rising_edge(clk)) then clk_div <= clk_div + '1' ;




process(clk_div(19)) begin

case (spd_cnt) is when "0001" => cl <= clk_div(19) and clk_div(15);

acl <= '0'; when "0010" => cl <= clk_div(19) and clk_div(16);

acl <= '0'; when "0100" => cl <= clk_div(19) and clk_div(18);

acl <= '0'; when "1000" => cl <= '1';

acl <= '0'; when "0000" => cl <= '0';

acl <= '1'; when others => null;

end case; end process;

end Behavioral; UCF File Name: DCmotor.ucf #DCmotor.ucf NET "clk" LOC = "p9" ; NET "spd_cnt<0>" LOC = "p79" ; NET "spd_cnt<1>" LOC = "p75" ; NET "spd_cnt<2>" LOC = "p72" ; NET "spd_cnt<3>" LOC = "p71" ; NET "cl" LOC = "p5" ; NET "acl" LOC = "p4" ;



5. External Lights Switching using Relay

BUS/STRIP CABLECPLD

XC9572

JTAG

Power

Supply

PC

CPLD Board

J2J6

DAC/Relay Interface Card

RELAY4 RELAY2

RELAY3 RELAY1

Figure 9: Interface Diagram of CPLD Board and Relay Interface Card

Relay Interface relay_out

outputs

4

Figure 10: Block Diagram of Relay Interface



VHDL File Name: relay_drive.vhd -- relay_drive.vhd -- relay_drive – DataFlow library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity relay_drive is Port ( relay_out : out STD_LOGIC_vector(3 downto 0)); end relay_drive; architecture DataFlow of relay_drive is begin

relay_out(0) <= '0'; --relay1 device(led) is off relay_out(1) <= '1'; --relay2 device(led) is on relay_out(2) <= '1'; --relay3 device(led) is on relay_out(3) <= '0'; --relay4 device(led) is off

end DataFlow; UCF File Name: relay_drive.ucf #relay_drive.ucf NET "relay_out<0>" LOC = "p5" ; NET "relay_out<1>" LOC = "p4" ; NET "relay_out<2>" LOC = "p3" ; NET "relay_out<3>" LOC = "p2" ;



6. Signal Generator Using DAC

BUS/STRIP CABLECPLD

XC9572

JTAG

Power

Supply

PC

CPLD Board

J2J6

DAC/Relay Interface Card

RELAY4 RELAY2

RELAY3 RELAY1

ToCRO

J5

Figure 11: Interface Diagram of CPLD Board and DAC Interface Card

Signal Generatorusing DAC

inputs

clk

dac_out

outputs

8rst

Figure 12: Block Diagram of Sine/Triangular/Square/Ramp Wave Generator using DAC

The DAC interface consists of 8 bit Digital to Analog Converter (DAC 0800). The outputs of which are converted to Voltages using OPAMP (LM324). The Voltage Outputs terminated at J6 (Vout) and corresponding 4mA-20mA at J7 Connector



t

V

0

VHDL File Name: DAC_Sine.vhd -- DAC_Sine.vhd -- DAC_Sine – Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity DAC_Sine is Port ( clk : in STD_LOGIC; -- 4MHz XTL_CLK rst : in STD_LOGIC; dac_out : out STD_LOGIC_VECTOR ( 7 downto 0 )); end DAC_Sine; architecture Behavioral of DAC_Sine is

signal c1 : std_logic_vector (3 downto 0); signal i : integer range 31 downto 0; type sine is array (0 to 31) of integer range 0 to 255; constant value : sine := ( 128, 146, 164, 182, 200, 218,236, 246, 255, 246, 236, 218,200, 182, 164, 146, 128, 110, 92, 74, 56, 38, 20, 06, 00,06, 20, 38, 56, 74, 92, 110);

begin

process (clk, rst) begin

if(rst='1') then c1 <=(others => '0');

elsif (clk'event and clk = '1') then c1 <= c1 + 4;


(θ=2,4,6,……) degree of sine using the equation V=5V +5V Sinθ

Eg: θ=0

1. V=5V +5V Sin θ = 5V 2. Resolution of the DAC: 8-bit (2pow8=256) Steps

V:10V(p.p)→ Full Scale Voltages So, 256 Steps/10V = 25.6 Steps per Volt. The Value Sent to DAC is (25.6 * 5)V=128.



process (c1(3)) begin

if rising_edge (c1(3)) then dac_out <= conv_std_logic_vector ( value (i), 8 ); i <= i + 1;

if (i = 31) then i <= 0;

end if; end if;

end process; end Behavioral; UCF File Name: DAC_Sine.ucf #DAC_Sine.ucf NET "clk" LOC = "p9" ; NET "rst" LOC = "p12" ; NET "dac_out<0>" LOC = "p81" ; NET "dac_out<1>" LOC = "p80" ; NET "dac_out<2>" LOC = "p79" ; NET "dac_out<3>" LOC = "p75" ; NET "dac_out<4>" LOC = "p72" ; NET "dac_out<5>" LOC = "p71" ; NET "dac_out<6>" LOC = "p70" ; NET "dac_out<7>" LOC = "p69" ;



t

V

0

VHDL File Name: DAC_Square.vhd -- DAC_Square.vhd -- DAC_Square – Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity DAC_Square is Port ( clk : in STD_LOGIC; -- 4MHz XTL_CLK rst : in STD_LOGIC; dac_out : out STD_LOGIC_VECTOR ( 7 downto 0 )); end DAC_Square; architecture Behavioral of DAC_Square is

signal count : std_logic_vector (7 downto 0); begin

process (clk, rst, count) begin

if(rst='1') then count <=(others => '0');

elsif (clk'event and clk = '1') then count <= count + 1;

end if; if (count(7) = '1') then

dac_out <= "11111111"; else

dac_out <= "00000000"; end if;

end process; end Behavioral;



UCF File Name: DAC_Square.ucf #DAC_Square.ucf NET "clk" LOC = "p9" ; NET "rst" LOC = "p12" ; NET "dac_out<0>" LOC = "p81" ; NET "dac_out<1>" LOC = "p80" ; NET "dac_out<2>" LOC = "p79" ; NET "dac_out<3>" LOC = "p75" ; NET "dac_out<4>" LOC = "p72" ; NET "dac_out<5>" LOC = "p71" ; NET "dac_out<6>" LOC = "p70" ; NET "dac_out<7>" LOC = "p69" ;



t

V

0

VHDL File Name: DAC_Triangular.vhd -- DAC_Triangular.vhd -- DAC_Triangular – Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity DAC_Triangular is Port ( clk : in STD_LOGIC; -- 4MHz XTL_CLK rst : in STD_LOGIC; dac_out : out STD_LOGIC_VECTOR ( 7 downto 0 )); end DAC_Triangular; architecture Behavioral of DAC_Triangular is

signal count : std_logic_vector (7 downto 0); signal ud : std_logic := '0';

begin

process (clk, rst) begin


elsif (clk'event and clk = '1') then if (ud='0') then

count <= count + 1; elsif (ud='1') then

count <= count - 1; end if;

end if; end process; dac_out <= count; -- Output the count value



process (clk) begin

if (clk'event and clk = '1') then if (count = "11111110") then

ud <= '1'; elsif (count = "00000001") then

ud <= '0'; end if;


end Behavioral; UCF File Name: DAC_Triangular.ucf #DAC_Triangular.ucf NET "clk" LOC = "p9" ; NET "rst" LOC = "p12" ; NET "dac_out<0>" LOC = "p81" ; NET "dac_out<1>" LOC = "p80" ; NET "dac_out<2>" LOC = "p79" ; NET "dac_out<3>" LOC = "p75" ; NET "dac_out<4>" LOC = "p72" ; NET "dac_out<5>" LOC = "p71" ; NET "dac_out<6>" LOC = "p70" ; NET "dac_out<7>" LOC = "p69" ;



t

V

0

VHDL File Name: DAC_Pos_Ramp.vhd -- DAC_Pos_Ramp.vhd -- DAC_Pos_Ramp - Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity DAC_Pos_Ramp is Port ( clk : in STD_LOGIC; -- 4MHz XTL_CLK rst : in STD_LOGIC; dac_out : out STD_LOGIC_VECTOR ( 7 downto 0 )); end DAC_Pos_Ramp; architecture Behavioral of DAC_Pos_Ramp is




elsif (clk'event and clk = '1') then count <= count + 1;

end if; end process; dac_out <= count;

end Behavioral;



UCF File Name: DAC_Pos_Ramp.ucf #DAC_Pos_Ramp.ucf NET "clk" LOC = "p9" ; NET "rst" LOC = "p12" ; NET "dac_out<0>" LOC = "p81" ; NET "dac_out<1>" LOC = "p80" ; NET "dac_out<2>" LOC = "p79" ; NET "dac_out<3>" LOC = "p75" ; NET "dac_out<4>" LOC = "p72" ; NET "dac_out<5>" LOC = "p71" ; NET "dac_out<6>" LOC = "p70" ; NET "dac_out<7>" LOC = "p69" ;



t

V

0

VHDL File Name: DAC_Neg_Ramp.vhd -- DAC_Neg_Ramp.vhd -- DAC_Neg_Ramp – Behavioral library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity DAC_Neg_Ramp is Port ( clk : in STD_LOGIC; -- 4MHz XTL_CLK rst : in STD_LOGIC; dac_out : out STD_LOGIC_VECTOR ( 7 downto 0 )); end DAC_Neg_Ramp; architecture Behavioral of DAC_Neg_Ramp is




elsif (clk'event and clk = '1') then count <= count - 1;

end if; end process; dac_out <= count;

end Behavioral;



UCF File Name: DAC_Neg_Ramp.ucf #DAC_Neg_Ramp.ucf NET "clk" LOC = "p9" ; NET "rst" LOC = "p12" ; NET "dac_out<0>" LOC = "p81" ; NET "dac_out<1>" LOC = "p80" ; NET "dac_out<2>" LOC = "p79" ; NET "dac_out<3>" LOC = "p75" ; NET "dac_out<4>" LOC = "p72" ; NET "dac_out<5>" LOC = "p71" ; NET "dac_out<6>" LOC = "p70" ; NET "dac_out<7>" LOC = "p69" ;

hdl manual 2012 4th sem 10esl48

Documents