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 Flip-Flop, JK Flip-Flip-Flop, D Flip-Flip-Flop, Edge Triggered D Flip-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 flip-flop 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 masing-masing 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).
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 kadang-kadang 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
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:
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, 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; initial begin #175 J = 0; K = 0; #200 J = 1; K = 0; #200 J = 1; K = 1; #100 ; end endmodule
2.1.3. Master Slave D Flip-Flop Skematik master slave D Flip Flop :
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; #85 D = 1; #15 D = 0; #120 D = 1; #25 D = 0; #200; end endmodule Hasil Simulasi :
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;
#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
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
Skematik 8 Bit Carry Look Ahead Adder yang dibentuk dari 2 buah 4 bit Look Ahead Carry Adder dan rangkaian LAC generate :
HDL Listing 8 bit Carry Look Ahead Adder: // 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;
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);
endmodule
//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 module TestLACA8bit1(); // Internal Declarations reg Cin; reg [7:0] A, B; wire [8:0] S;
LookAheadCarryAdder8 LACA1 (Cin, A, B, S); initial 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 : 2.3. 3 To 8 Decoder
Truth table 3 to 8 Decoder:
Listing HDL 3 to 8 decoder : // 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;
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 8 to 1 selector :
HDL Listing 8 to 1 Selector : // 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
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 :
2.5. 8 To 3 Priority Encoder
Truth table:
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; 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:
3. Penutup Simpulan
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-50022-1, Addison-Wesley VLSI Systems Series, 1997.
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.
