베릴로그

1. 개요

2. 특징

3. 역사

4. 문법

4.1. 모듈

• 모듈 선언부: 모듈의 이름, input 및 output 포트 등을 선언함
• 신호 선언부: 모듈 내부에서 사용될 자료형인 wire, reg 등을 선언함
• 동작 선언부: always, assign 등을 사용하여 모듈의 기능, 동작, 구조 등을 선언함

/* 모듈 선언부 */
// 모듈의 이름, 입출력 포트, parameter 등을 선언함 //
module my_and_module (a, b, c); 
    /* 신호 선언부 */
    // wire, reg, parameter 등 선언함
    input wire a, b;
    output wire c;

    /* 동작 선언부 */
    // assign, always, initial, 하위 모듈 인스턴스 등 선언함
    assign c = a & b;
endmodule

4.2. 논리값

4.3. 상수

• bit 수를 생략할 시 그 수는 32 bit로 간주한다.
• 진수는 16진수('h, 'H), 10진수('d, 'D), 8진수('o, 'O), 2진수('b, 'B)를 나타낼 수 있으며, 대소문자 구별이 없다.

429       // 32 bit 10진수 429
'hf12     // 32 bit 16진수 f12
8'Ha12    //  8 bit 16진수 a12
32'd2020  // 32 bit 10진수 2020
16'o20    // 16 bit  8진수 20
4'b0110   //  4 bit  2진수 0110

4.4. 자료형

wire        w1;            //      1 bit wire
reg         reg_a, reg_b;  //      1 bit reg
reg   [7:0] reg_c;         //      8 bit reg (벡터)
wire [15:0] d_in;          //     16 bit wire (벡터)
reg   [7:0] reg_d [0:255]; //  8*256 bit reg (2차원 배열)

4.5. 할당문

4.5.1. 연속 할당문

wire wire_a;
assign wire_a = a & b; // assign 문을 사용한 연속 할당

wire wire_b = a & b; // wire 자료형 선언과 동시에 할당문 선언

4.5.2. 절차형 할당문

4.5.2.1. initial 블록

reg reg_a;
initial begin
    reg_a = 1'b0;
end

4.5.2.2. always 블록

• 순차 회로를 모델링할 때, always 블록에서는 non-blocking 할당문(<=)을 사용할 것
• 조합 회로를 모델링할 때, always 블록에서는 blocking 할당문(=)을 사용할 것
• 동일한 always 블록 내에서는 non-blocking 할당문(<=)과 blocking 할당문(=)을 혼용해서 사용하지 않을 것

module top (
    input  wire clk, rst_n,
    input  wire a, b,
    output reg  q
);

reg y;

// blocking 할당문을 사용하여 조합 회로를 모델링
always @(*) begin
    y = a ^ b;
end

// non-blocking 할당문을 사용하여 순차 회로를 모델링
always @(posedge clk) begin
    if(!rst_n) q <= 1'b0;
    else       q <= y;
end

endmodule

4.5.2.3. 타이밍 제어

always @(*) // 모든 입력 신호를 감지
always @(a) // a 값이 변할때마다 감지 (a가 0에서 1로 또는 1에서 0으로 변할때 모두 감지)
always @(posedge clk) // clk의 상승에지를 감지
always @(posedge clk, negedge rst_n) // clk의 상승에지 또는 rst_n의 하강에지를 감지

4.6. 조건문

module mux (
    input  wire       a,
    input  wire       b,
    input  wire       c,
    input  wire       d,
    input  wire [1:0] sel,
    output wire       out
);

assign out = (sel == 2'b00) ? a :
             (sel == 2'b01) ? b :
             (sel == 2'b10) ? c :
             (sel == 2'b11) ? d : x;

endmodule

module mux (
    input  wire       a,
    input  wire       b,
    input  wire       c,
    input  wire       d,
    input  wire [1:0] sel,
    output wire       out
);

always @(*) begin
         if(sel == 2'b00) out = a;
    else if(sel == 2'b01) out = b;
    else if(sel == 2'b10) out = c;
    else if(sel == 2'b11) out = d;
    else                  out = x;
end

endmodule

module mux (
    input  wire       a,
    input  wire       b,
    input  wire       c,
    input  wire       d,
    input  wire [1:0] sel,
    output wire       out
);

always @(*) begin
    case(sel)
        2'b00:   out = a;
        2'b01:   out = b;
        2'b10:   out = c;
        2'b11:   out = d;
        default: out = x;
    endcase
end

endmodule

4.7. 반복문

4.8. 모듈 포트

module my_module (a, b, c);
    input a; // 자료형을 명시하지 않으면 wire로 할당됨
    input wire b;
    output reg c;

module my_module (
    input a, // bit 수를 명시하지 않으면 1 bit로 할당됨
    input wire [2:0] b,
    output reg c
);

4.9. 모듈 인스턴스

module top_module;

wire [7:0] d, e, r; // 포트 매핑을 위한 wire 선언은 필수다
submodule instance_1 ( 
    .a(d), // submodule의 포트 이름이 a인 경우
    .b(e),
    .c( ), // 사용하지 않는 포트는 빈 괄호로 두거나 아예 포트 이름을 생략함
    .q(r)
);

endmodule

4.10. 생성문

module my_xor #(
   parameter WIDTH=8
)
(
   input  wire [WIDTH-1:0] a,
   input  wire [WIDTH-1:0] b,
   output wire [WIDTH-1:0] out
);

genvar i;
generate
   for(i = 0; i < WIDTH; i = i + 1) begin
      assign out[i] = a[i] ^ b[i];
   end
endgenerate

endmodule

module my_xor #(
   parameter WIDTH=8
)
(
   input  wire [WIDTH-1:0] a,
   input  wire [WIDTH-1:0] b,
   output wire [WIDTH-1:0] out
);

assign out[0] = a[0] ^ b[0];
assign out[1] = a[1] ^ b[1];
assign out[2] = a[2] ^ b[2];
assign out[3] = a[3] ^ b[3];
assign out[4] = a[4] ^ b[4];
assign out[5] = a[5] ^ b[5];
assign out[6] = a[6] ^ b[6];
assign out[7] = a[7] ^ b[7];

endmodule

module mode_selector #(
   parameter MODE = 0
)
(
   input  wire [7:0] a
   input  wire [7:0] b,
   output wire [7:0] result
);
   generate
           if (MODE == 0) assign result = a + b;
      else if (MODE == 1) assign result = a * b;
      else                assign result = a & b;
   endgenerate
endmodule

4.11. 시스템 태스크(system tasks)

• $display
  문자열과 지정한 신호의 값을 화면에 출력한다. 자동으로 개행된다.
  $display("Hello World!");
$display("%b, %d", a, b);
• $write
  기능은 $display와 동일하나 개행 없이 출력한다.
• $monitor
  지정한 신호의 값이 바뀌면 화면에 출력한다.
• $stop
  시뮬레이션을 중단한다.
  $finish와 달리 control이 여전히 simulator에 있으며 simulator가 Interative Mode가 된다.
• $finish
  시뮬레이션을 종료한다.
  $stop과 달리 control이 OS로 돌아온다.
• $time
  현재의 시뮬레이션 시간
  $display($time);
• $random
  랜덤값을 반환한다.
  $display($random);

5. 예제

5.1. 조합 회로(combinational circuit)

5.1.1. 인코더

module encoder (
   input  wire [3:0] x,
   output reg  [1:0] y // output y의 자료형이 wire가 아니라 reg임에 유의
);

   always @(*) begin
      if     (x == 4'b0001) y = 2'b00; // non-blocking 할당문(<=)이 아닌, blocking 할당문(=)을 사용함에 유의
      else if(x == 4'b0010) y = 2'b01;
      else if(x == 4'b0100) y = 2'b10;
      else if(x == 4'b1000) y = 2'b11;
      else                  y = 2'bxx; // latch 생성을 피하기 위해서 대신 else 사용함
   end

endmodule

module encoder (
   input  wire [3:0] x,
   output wire [1:0] y  // output y의 자료형이 reg가 아니라 wire임에 유의
);

   assign y[0] = (!x[3] && !x[2] &&  x[1] && !x[0]) || (x[3] && !x[2] && !x[1] && !x[0]);
   assign y[1] = (!x[3] &&  x[2] && !x[1] && !x[0]) || (x[3] && !x[2] && !x[1] && !x[0]);

endmodule

5.2. 순차 회로(sequential logic)

module d_flip_flop (
   input  wire clk,
   input  wire d,
   output reg  q,
   output reg  q_bar
);

   always @(posedge clk) begin
      q     <= d;
      q_bar <= ~d;
   end

endmodule

module down_counter #(
   parameter WIDTH = 8
)
(
   input  wire             clk,
   input  wire             load,
   output wire [WIDTH-1:0] Q
);

   reg [WIDTH-1:0] cnt;

   always @(posedge clk) begin
      if(load) cnt <= {WIDTH{1’b1}}; // 8'b1111_1111
      else     cnt <= cnt - 1’b1;
   end

   assign Q = cnt;

endmodule

6. 여담

6.1. 자주 사용되는 용어

• 시뮬레이션: 디자인을 실제 하드웨어를 제작하지 않고, 소프트웨어 환경에서 설계된 하드웨어의 동작을 가상으로 구현하고 분석하는 과정.
• 테스트벤치(testbench): 디자인의 기능 및 성능을 검증하기 위해 사용되는 시뮬레이션 환경. 테스트벤치에서 입력 신호를 생성하고, 출력 결과를 관찰하거나 비교하여 동작을 확인함. 디자인과 마찬가지 테스트벤치 또한 HDL로 작성함.
• DUT(Design Under Test): 테스트 대상이 되는 디자인.
• 합성(synthesis): HDL로 작성된 코드를 실제 논리 게이트 수준(AND, OR, NOT 등)의 회로로 변환하는 과정. 타겟 하드웨어(FPGA나 ASIC)에 적합한 라이브러리 셀로 매핑하여, 최종적으로 게이트 수준으로 기술된 회로[9]가 생성됨.
• 배치 및 배선(place and route): 합성된 회로를 물리적 레이아웃에 매핑하고 연결하는 과정.

6.2. SystemVerilog

7. 관련 책과 자료

• Verilog, Formal Verification and Verilator Beginner's Tutorial - Daniel E. Gisselquist
• Verilog Quick Reference Guide - Sutherland HDL (PDF)
• Verilog Tutorial - Deepak Kumar Tala
• Verilog Tutorials and Examples - Russell Merrick(nandland)
• Verilog Projects - Van Loi Le(FPGA4student)
• Verilog Tutorial (ChipVerify)
• HDLBits - Henry Wong
• Iverilog (온라인 시뮬레이터)

8. 관련 문서

• 집적 회로
• ASIC
• FPGA
• 논리 회로
• VHDL
• systemC