IP Core Design Rangkaian Sekuensial dan Kombinasional

65

Jurnal Kompetensi Teknik Vol.1, No. 2, Mei 2010

IP Core Design Rangkaian Sekuensial dan Kombinasional Tatyantoro Andrasto Jurusan Teknik Elektro, Universitas Negeri Semarang

Abstract: Pada proses perancangan rangkaian terintegrasi secara digital dilakukan melalui beberapa tahap. Yang pertama dilakukan adalah mereview kepada desain rangkaian diskrit sesuai dengan karakteristik yang dikehendaki. Kemudian melakukan proses pembuatan IP Core untuk masing-masing modul (blok) dengan menggunakan VHDL sehingga apabila terjadi kesalahan mudah melacaknya. Apabila sudah dianggap benar kemudian dibuat test bench agar dapat dilakukan proses simulasi untuk hasil rancangan IP Core tersebut. Kemudian dilakukan simulasi menggunakan FPGA Advantage agar dapat diketahui apakah untuk masing-masing input dan output bekerja dengan benar. Hasil dari eksperimen ini adalah IP Core untuk rangkaian SR FlipFlop, JK Flip-Flop, D Flip-Flop, Edge Triggered D Flip-Flop, 8 Bit Ripple Carry Adder, 8 Bit Carry Look Ahead Adder, 3 to 8 Decoder, 8 to 1 Selector dan 8 to 3 Priority Encoder beserta dengan tes bench nya. Key word : test bench, FPGA, IP core

1. Pendahuluan Flip-flop adalah rangkaian digital yang digunakan untuk menyimpan satu bit secara semi permanen sampai ada suatu perintah untuk menghapus atau mengganti isi dari bit yang disimpan. Prinsip dasar dari flipflop adalah suatu komponen elektronika dasar seperti transistor, resistor dan dioda yang dirangkai menjadi suatu gerbang logika yang dapat bekerja secara sekuensial. HA dan FA hanya dirancang untuk menjumlahkan dua masukan yang masingmasing 1 bit. Dengan menyusun n-buah FA secara paralel, kita dapat menjumlahkan n bit bilangan. Konstruksinya sangat sederhana, tinggal menghubungkan CARRY OUT dari bit yang lebih rendah ke CARRY IN pada bit yang lebih tinggi, dan seterusnya. Pada kenyataannya, paralel adder lebih sering diimplementasikan dengan n buah modul Paralel Adder yang lebih kecil dari pada dibangun dari Full Adder. Sistem ini mempunyai satu kelemahan. Jika jumlah bit terlalu banyak (otomatis jumlah FA akan banyak), maka CARRY akan merambat dari satu FA ke FA lainnya, sehingga FA yang terakhir akan menghasilkan CARRY jauh lebih lambat

dari FA pertama (ripple carry effect). Ini menjadi masalah jika rangkaian seperti ini diterapkan dalam sistem yang bekerja dengan kecepatan tinggi, misalnya dalam ALU pada CPU. Solusi untuk mengatasi masalah ini, diantaranya adalah perbaikan yang disebut LOOK-AHEAD CARRY ADDER serta CARRY SAVE ADDER. PARALEL ADDER atau RIPPLE-CARRY ADDER hanya efektif untuk aplikasi yang memerlukan penjumlahan sampai dengan 16 bit pada kecepatan menengah dan tinggi. 1.1. Look Ahead Carry Adder Ide Look Ahead Carry Adder (LAC-Adder) pada dasarnya adalah mengurangi proses perambatan CARRY yang dilakukan secara cascade pada n-BIT PARALEL ADDER. Pada LAC ADDER, dibuat rangkaian carry khusus untuk setiap FA, sehingga proses perambatan CARRY-nya praktis sama atau tidak terlalu jauh berbeda antar slice yang berbeda posisinya. Kombinasi Cn, An, dan Bn yang dapat menghasilkan Carry out. Dari empat kemungkinan tersebut dapat kita identifikasikan bahwa terdapat Carry yang diakibatkan oleh saluran A dan B (CARRY GENERATE) dan Carry yang diakibatkan oleh adanya Cin (CARRY PROPAGATE).

66


Bandingkan dengan PARALEL ADDER yang carry-nya hanya berasal dari satu tahap sebelumnya saja. Berdasarkan persamaan-persamaan tersebut kita dapat merancang ulang FA sehingga memiliki keluaran P (propagate) dan G (generate). Disamping kelebihannya, LAC-Adder memiliki beberapa kelemahan sebagai berikut : • Rangkaian pembangkit CARRY untuk setiap tahap FA berbeda. • Rangkaian pembangkit CARRY untuk setiap tahap berubah semakin kompleks untuk bit yang lebih tinggi. Sistem ini dapat juga disusun secara cascade, misalnya 3 modul 4-bit LAC ADDER disusun membentuk 12 bit LAC ADDER.

1.2. Carry Save Adder Kebutuhan penjumlahan biner kadangkadang tidak melibatkan hanya dua bilangan, tetapi bisa sejumlah bilangan dan ingin dijumlahkan bersamaan secara simultan. Untuk melakukan hal tersebut dapat digunakan “fast” ADDER yang disebut CARRY SAVE ADDER (CSA). CSA merupakan salah satu alternatif untuk implementasi ADDER berkecepatan tinggi tanpa dihadapkan pada masalah perambatan CARRY. CSA mempunyai struktur matriks yang sederhana dan teratur, sehingga dengan mudah dikembangkan untuk menangani jumlah bit atau jumlah bilangan yang lebih besar. Algoritma CSA dapat dinyatakan sebagai berikut : “Jumlahkan bit-bit yang ingin dijumlahkan tanpa menghiraukan CARRY, kemudian jumlahkan hasilnya dengan CARRY yang sudah digeser satu posisi”.

2. Pembahasan 2.1. Sequential Design 2.1.1. Master Slave S R Flip-Flop Skematik Master Slave SR Flip Flop :

Tabel input output SR Flip-Flop :

Listing HDL : module MSSRFF (S, R, Clk, Q, Qn); input S, R, Clk; output Q, Qn; wire OutSRFF, OutSRFFn, Clkn; assign Clkn = ! Clk; SRFF SRFF1 (S, R, Clk, OutSRFF, OutSRFFn); SRFF SRFF2 (OutSRFF, OutSRFFn, Clkn, Q, Qn); endmodule module SRFF (S, R, C, Q, Qn); input S, R, C; output Q, Qn; reg Q; always @ (S or R or C) begin if (C) case ({S,R}) 0 : Q = Q; //no change 1 : Q = 0; //reset 2 : Q = 1; //set endcase else ; end assign Qn = ! Q; endmodule Test bench yang digunakan : module testMSSRFF(); wire Q, Qn; MSSRFF MSSRFF1 (S, R, Clk, Q, Qn); initial begin

67


Clk = 0; S = 0; R = 1; end always #50 Clk = ! Clk; initial begin #175 S = 0; R = 0; #200 S = 1; R = 0; #200 S = 1; R = 1; #100 ; end endmodule Hasil Simulasi :

2.1.2. Master Slave JK Flip-Flop Skematik Master Slave JK Flip Flop:

OutSRFF, OutSRFFn); SRFF SRFF2 (OutSRFF, OutSRFFn, Clkn, Q, Qn); endmodule module SRFF (S, R, C, Q, Qn); input S, R, C; output Q, Qn; reg Q, Qn; always @ (S or R or C) begin if (C) case ({S,R}) 0 : Q = Q; //no change 1 : Q = 0; //reset 2 : Q = 1; //set endcase else ; end assign Qn = ! Q; endmodule Test bench : module testMSJKFF(); // Internal reg J, K, Clk; wire Q, Qn; MSSRFF MSJKFF1 (J, K, Clk, Q, Qn); initial begin Clk = 0; J = 0; K = 1; end always #50 Clk = ! Clk;

SR Flip-Flop didefinisikan seperti pada SR Flip-Flop pada Master Slave SR Flip-Flop HDL Listing : module MSJKFF (J, K, Clk, Q, Qn); input J, K, Clk; output Q, Qn; wire OutSRFF, OutSRFFn, Clkn, OutAnd1, OutAnd2; assign Clkn = ! Clk; assign OutAnd1 = J & Qn; assign OutAnd2 = K & Q; SRFF SRFF1 (OutAnd1, OutAnd2, Clk,

initial begin #175 J = 0; K = 0; #200 J = 1; K = 0; #200 J = 1; K = 1; #100 ; end endmodule

68

2.1.3. Master Slave D Flip-Flop Skematik master slave D Flip Flop :


#85 D = 1; #15 D = 0; #120 D = 1; #25 D = 0; #200; end endmodule Hasil Simulasi :

HDL Listing : module MSDFF (D,Clk,Q); input D,Clk; output Q; wire OutDff1; wire Clkn; assign Clkn = ! Clk; DFF_RISE DFF_RISE1 (D, Clk, OutDff1); DFF_FALL DFF_FALL1 (OutDff1, Clkn, Q); endmodule module DFF_FALL (D,Clk,Q); input D,Clk; output Q; reg Q; always @ (negedge Clk) Q <= D; endmodule module DFF_RISE (D,Clk,Q); input D,Clk; output Q; reg Q; always @ (posedge Clk) Q <= D; endmodule module TesMSDFF (); reg D, Clk; wire Q; MSDFF MSDFF1 (D,Clk,Q); initial begin Clk = 0; D = 0; end always #50 Clk = ! Clk; initial begin #225 D = 1; #200 D = 0;

2.1.4. Edge Triggered D Flip-Flop Skematik Edge triggered D Flip Flop

HDL Listing : module ET_DFF (D,Clk,Q); input D,Clk; output Q; reg Q; always @ (posedge Clk or negedge Clk) Q <= D; endmodule Test Bench : module TesETDFF (); reg D, Clk; wire Q; ET_DFF ET_DFF1 (D,Clk,Q); initial begin Clk = 0; D = 0; end always #50 Clk = ! Clk; initial begin #225 D = 1; #200 D = 0; #85 D = 1; #15 D = 0; #120 D = 1; #25 D = 0;

69


#200; end endmodule Hasil Simulasi :

2.2. Combinational Design 2.2.1. 8 Bit Ripple Carry Adder Truth Table dari Full Adder:

Skematik Full Adder :

Skematik 8 Bit RCA

Listing HDL Ripple Carry Adder: // 8 bit Ripple Carry Adder module RippleCarryAdder8 (Cin,A,B,Sum); input Cin; input [7:0] A,B; output [8:0] Sum; wire Cout1,Cout2,Cout3,Cout4,Cout5,Cout6, Cout7; FullAdd FullAdd1 (A[0], B[0], Cin, Sum[0], Cout1); FullAdd FullAdd2 (A[1], B[1], Cout1, Sum[1], Cout2); FullAdd FullAdd3 (A[2], B[2], Cout2, Sum[2], Cout3); FullAdd FullAdd4 (A[3], B[3], Cout3, Sum[3], Cout4); FullAdd FullAdd5 (A[4], B[4], Cout4, Sum[4], Cout5); FullAdd FullAdd6 (A[5], B[5], Cout5, Sum[5], Cout6); FullAdd FullAdd7 (A[6], B[6], Cout6, Sum[6], Cout7); FullAdd FullAdd8 (A[7], B[7], Cout7, Sum[7], Sum[8]); endmodule //modul Full Adder module FullAdd (A, B, Cin, Sum, Cout); input A, B, Cin; output Sum, Cout; wire AplusB, CoutHA1, CoutHA2; HalfAdd HalfAdd1 (A, B, AplusB, CoutHA1); HalfAdd HalfAdd2 (AplusB, Cin, Sum, CoutHA2); assign Cout = CoutHA1 | CoutHA2; endmodule //modul Half Adder module HalfAdd (A, B, Sum, Cout); input A, B; output Sum, Cout; assign Sum = A ^ B; assign Cout = A & B; endmodule Test bench : module testrca8bit(); // Internal Declarations reg [7:0] A, B; reg Cin; wire [8:0] Sum; RippleCarryAdder8 RCA8bit (Cin,A,B,Sum); initial

70

begin Cin = 0;A = 0;B = 0; end initial begin #100 A = 8;Cin = 0;B = 0; #100 A = 6;Cin = 0;B = 2; #100 A = 0;Cin = 1;B = 9; End Endmodule Hasil simulasi 3 operasi penjumlahan :

2.2.2. 8 Bit Carry Look Ahead Adder Skematik 4 Bit Carry Look Ahead Adder


assign S[8] = (P2 & G1) | (P2 & P1 & Cin) | G2; endmodule // 4 bit Look Ahead Carry Adder module LookAheadCarryAdder4 (Cin, A, B, S, Pm, Gm); input Cin; input [3:0] A,B; output [3:0] S; output Pm, Gm; wire C1, C2, C3; wire [2:0] P, G; assign C1 = G[0] | (P[0] & Cin); assign C2 = G[1] | (P[1] & G[0]) | (P[1] & P[0] & Cin); assign C3 = G[2] | (P[2] & G[1]) | (P[2] & G[1] & G[0] & Cin); FullAdder FullAdder1 (Cin, A[0], B[0], S[0], P[0], G[0]); FullAdder FullAdder2 (C1, A[1], B[1], S[1], P[1], G[1]); FullAdder FullAdder3 (C2, A[2], B[2], S[2], P[2], G[2]); FullAdder FullAdder4 (C3, A[3], B[3], S[3], Pm, Gm);

Skematik 8 Bit Carry Look Ahead Adder yang dibentuk dari 2 buah 4 bit Look Ahead Carry Adder dan rangkaian LAC generate :

endmodule

HDL Listing 8 bit Carry Look Ahead Adder:

module TestLACA8bit1(); // Internal Declarations reg Cin; reg [7:0] A, B; wire [8:0] S;

// 8 bit Look Ahead Carry Adder module LookAheadCarryAdder8 (Cin, A, B, S); input Cin; input [7:0] A,B; output [8:0] S; wire G1, G2, P2, P1, OutOr1; LookAheadCarryAdder4 LACA1 (Cin, A[3:0], B[3:0], S[3:0], P1, G1); LookAheadCarryAdder4 LACA2 (OutOr1, A[7:4], B[7:4], S[7:4], P2, G2); assign OutOr1 = (P1 & Cin) | G1;

//modul Full Adder module FullAdder (Cin, A, B, S, P, G); input Cin, A, B; output S, P, G; assign G = A & B; assign P = A ^ B; assign S = P ^ Cin; endmodule

LookAheadCarryAdder8 LACA1 (Cin, A, B, S); initial begin Cin = 0; A = 0; B = 0; end initial

71


begin #100 A = 8; Cin = 0; B = 0; #100 A = 6; Cin = 0; B = 2; #100 A = 0; Cin = 1; B = 9; end endmodule Hasil Simulasi :

2.3. 3 To 8 Decoder

Decoder3to8 Dec3to8 (A, Y); initial begin A = 0; #100 A = 2; #100 A = 5; #100 A = 7; end endmodule Hasil simulasi :

2.4. 8 To 1 Selector

Truth table 3 to 8 Decoder: Truth table 8 to 1 selector :

Listing HDL 3 to 8 decoder : HDL Listing 8 to 1 Selector : // 3 to 8 decoder module Decoder3to8 (A, Y); input [2:0] A; output [7:0] Y; reg [7:0] Y; always @(A) begin case (A) 0 : Y = 8'b 00000001; 1 : Y = 8'b 00000010; 2 : Y = 8'b 00000100; 3 : Y = 8'b 00001000; 4 : Y = 8'b 00010000; 5 : Y = 8'b 00100000; 6 : Y = 8'b 01000000; 7 : Y = 8'b 10000000; default : Y = 8'b X; endcase end endmodule Testbench : module test3to8decoder1(); // Internal Declarations reg [2:0] A; wire [7:0] Y;

// 8 to 1 selector module Selector8to1 (Sel, A0, A1, A2, A3, A4, A5, A6, A7, Y); input [2:0] Sel; input A0, A1, A2, A3, A4, A5, A6, A7; output Y; reg Y; always @(Sel or A0 or A1 or A2 or A3 or A4 or A5 or A6 or A7) case (Sel) 0 : Y = A0; 1 : Y = A1; 2 : Y = A2; 3 : Y = A3; 4 : Y = A4; 5 : Y = A5; 6 : Y = A6; 7 : Y = A7; default : Y = A0; endcase endmodule Test bench : module test8to1sel1(); // Internal Declarations

72

reg [2:0] Sel; reg A0, A1, A2, A3, A4, A5, A6, A7; wire Y; Selector8to1 Sel8to1 (Sel, A0, A1, A2, A3, A4, A5, A6, A7, Y); initial begin A0 = 0; A1 = 0; A2 = 0; A3 = 0; A4 = 1; A5 = 1; A6 = 1; A7 = 1; #100 Sel = 1; #100 Sel = 7; #100 Sel = 3; #100 Sel = 6; end endmodule Hasil simulasi dengan 4 input berbeda :


default : begin EnOut = 0; Y = 3'b X; end endcase end endmodule Test bench yang digunakan : module TestPrioEnc8to3 (); // Internal Declarations reg [7:0] A; wire EnOut; wire [2:0] Y; PrioEnc8to3 PrioEnc8to3a (A, EnOut, Y); initial begin A = 0; #100 A = 1; #100 A = 7; #100 A = 3; #100 A = 6; end endmodule Hasil simulasi dengan 5 input berbeda:

2.5. 8 To 3 Priority Encoder Truth table:

3. Penutup Simpulan Listing HDL dengan verilog : // 8 to 3 Priority Encoder module PrioEnc8to3 (A, EnOut, Y); input [7:0] A; output EnOut; output [2:0] Y; reg EnOut; reg [2:0] Y; always @(A) begin EnOut = 1; casex (A) 8'b 1XXXXXXX : Y = 7; 8'b 01XXXXXX : Y = 6; 8'b 001XXXXX : Y = 5; 8'b 0001XXXX : Y = 4; 8'b 00001XXX : Y = 3; 8'b 000001XX : Y = 2; 8'b 0000001X : Y = 1; 8'b 00000001 : Y = 0;

Berdasarkan pada eksperimen di atas telah berhasil dibuat rangkaian kombinasional dan sekuensial dalam bentuk IP Core beserta dengan test banch-nya sehingga dapat dilakukan proses simulasi dengan menggunakan FPGA Advantage 5. Semua devais berfungsi sesuai dengan komponen diskritnya.

Daftar Pustaka Smith, Douglas J., HDL Chip Design, ISBN 0-9651934-3-8, Doone Publications, 1996. Smith, Michael J. S. , Application-Specific Integrated Circuit, ISBN 0-201-500221, Addison-Wesley VLSI Systems Series, 1997. Tutorial FPGA Adv 5.2, Mentor Graphics


Weste, N. H. E., and K. Eshraghian.. Principles of CMOS VLSI Design: A Systems Perspective. 2nd ed. Reading, MA: Addison-Wesley, 713 p. ISBN 0-201-53376-6. TK7874.W46. Concentrates on full-custom design., 1993. Glasser, L. A., and D.W. Dobberpuhl. The Design and Analysis of VLSI Circuits. Reading, MA: Addison-Wesley, 473 p. ISBN 0-201-12580-3. TK7874.G573. Detailed analysis of circuits, but largely nMOS., 1985. Mead, C. A., and L. A. Conway., Introduction to VLSI Systems. Reading, MA: Addison-Wesley, 396 p. ISBN 0-201-04358-0. TK7874.M37. 1980.

73

74


IP Core Design Rangkaian Sekuensial dan Kombinasional

Recommend Documents