무한 정보 시대

산술 회로

덧셈 및 뺄셈과 같은 산술 연산은 프로세서 논리 설계에 자주 사용됩니다. 모든 프로세서의 산술 및 논리 단위(ALU)는 더하기, 빼기, 증가 및 감소 연산을 수행하도록 설계되었습니다. 산술 설계는 원하는 성능을 달성하기 위해 합성 가능한 Verilog 코드로 설명되어야 합니다.

가산기

가산기는 두 이진수의 이진수 덧셈을 수행하는 데 사용됩니다. 가산기는 서명되거나 서명되지 않은 덧셈 연산에 사용됩니다.

반가산기

두 개의 입력 a_in, b_in을 갖고 단일 비트 출력 sum_out, carry_out을 생성하는 반가산기를 고려하십시오. 여기서 sum_out은 가산기 결과이고 carry_out은 캐리 출력입니다.

반가산기의 진리표

module half_adder ( input a_in, b_in, output sum_out, carry_out );
assign sum_out = a_in ^ b_in;
assign carry_out = a_in & b_in;
endmodule

전가산기

전가산기는 덧셈을 수행하는 데 사용됩니다. 이진 입력을 a_in, b_in, c_in으로 간주하고 단일 비트 이진 출력을 sum_out, carry_out으로 간주합니다.

전가산기의 진리표

module full_adder ( input a_in, b_in, c_in, output sum_out, carry_out );
assign { carry_out, sum_out } = a_in + b_in + c_in;
endmodule

뺄셈기

뺄셈기는 두 이진수의 이진수 빼기를 수행하는 데 사용됩니다.

반감산기

입력이 _in, b_in이고 단일 출력 diff_out, rider_out을 생성하는 반감기를 고려하십시오. 여기서 diff_out은 차등 출력이고, borrow_out은 차입 출력입니다.

module half_subtractor ( input a_in, b_in, output diff_out, borrow_out );
assign diff_out = a_in ^ b_in;
assign borrow_out = (~a_in) & b_in;
endmodule

완전 감산기

전체 감산기는 빼기를 수행하는 데 사용됩니다. a_in, b_in, c_in으로 명명된 단일 비트 입력과 diff_out, borrow_out으로 단일 비트 이진 출력입니다.

module full_subtractor ( input a_in, b_in, c_in, output diff_out, borrow_out );
assign { borrow_out, diff_out } = a_in- b_in - c_in;
endmodule

조합 논리는 논리 게이트로 구현되며 조합 논리에서 출력은 현재 입력의 함수입니다. 디자이너의 목표는 최소한의 논리 게이트 또는 논리 셀을 사용하여 논리를 구현하는 것입니다. 최소화 기법은 K-map, Boolean algebra, Shannon의 확장 정리입니다.

디자이너의 사고 과정은 디자인이 더 적은 논리 밀도로 더 나은 성능을 갖도록 해야 합니다. 면적 최소화 기술은 조합 논리 또는 부울 함수의 설계에서 중요한 역할을 합니다.

구성의 역할

조합 논리를 모델링하기 위해 할당 및 always @ 구문을 사용합니다. Always procedural 블록 내에서 if와 else로 구성하고 대부분의 경우 멀티플렉서 종류의 논리를 추론합니다.

if-else는 순차 구조이고 구문은 다음과 같습니다.

if (condition)

//blocking assignment executed if condition is true

else

// blocking assignment is executed if condition specified in if () is false

NOT 또는 논리 반전

NOT 논리는 반전 논리라고도 합니다.

합성 가능한 설계는 다음 예제와 같다.

module not_gate( input a_in, output reg y_out);
always@(a_in)
begin
  y_out = ~a_in;
end
endmodule

module not_gate( input a_in, output y_out);
assign y_out = ~a_in;
endmodule

NOT 게이트의 진리표

OR 논리

OR 논리는 입력 중 하나가 논리 1일 때 논리 1로 출력을 생성합니다.

OR 게이트 진리표

module or_gate(input a_in, b_in , output reg y_out);
always@(a_in, b_in)
begin
  if ( a_in==0 && b_in ==0)
    y_out = 0;
  else
    y_out = 1;
end
endmodule

다음 그림은 OR 논리의 RTL 개략도이며, OR 논리 게이트의 입력 포트는 a_in, b_in, 출력 포트는 y_out입니다. 회로도에서 볼 수 있듯이 추론된 논리는 2:1 멀티플렉서 및 기타 연산자를 사용하여 논리를 추론합니다. 합성 결과는 EDA 도구에 따라 다르며 ASIC 및 FPGA 설계의 경우 합성 결과가 다를 수 있습니다.

다중 입력 OR 게이트의 경우 비트 연산자( | )를 사용할 수 있습니다.

module or_gate(input [7:0] a_in, b_in , output [7:0] y_out);
assign y_out = a_in | b_in;
endmodule

NOR 논리

NOR 논리는 OR 논리의 반전입니다.

NOR 논리의 진리표

module nor_gate(input a_in, b_in , output reg y_out);
always@(a_in, b_in)
begin
  if ( a_in==0 && b_in ==0)
    y_out = 1;
  else
    y_out = 0;
end
endmodule

NOR 논리 게이트의 입력 포트는 a_in, b_in, 출력 포트는 y_out입니다. 그림과 같이 추론된 논리는 등호 연산자와 AND 게이트를 사용하여 NOR 게이트를 구현합니다.

다중 입력 OR 게이트의 경우 비트 연산자 OR( | )의 비트 NOT(~)을 사용할 수 있습니다.

module nor_gate(input [7:0] a_in, b_in , output [7:0] y_out);
assign y_out = ~(a_in | b_in);
endmodule

AND 논리

AND 논리는 입력 a_in, b_in이 모두 논리 1일 때 논리 1로 출력을 생성합니다.

AND 논리의 진리표

module and_gate(input a_in, b_in , output reg y_out);
always@(a_in, b_in)
begin
  if ( a_in==1 && b_in ==1)
    y_out = 1;
  else
    y_out = 0;
end
endmodule

낸드 로직

NAND는 AND 논리의 반전입니다.

NAND 논리의 진리표

module nand_gate(input a_in, b_in , output reg y_out);
always@(a_in, b_in)
begin
  if ( a_in==1 && b_in ==1)
    y_out = 0;
  else
    y_out = 1;
end
endmodule

NAND 로직의 RTL 회로도는 다음 그림과 같으며, NAND 로직 게이트의 입력 포트는 a_in, b_in으로 명명되고 출력은 y_out으로 명명됩니다. 추론된 논리는 멀티플렉서를 사용하여 AND의 NOT을 생성합니다.

다중 입력 NAND 게이트는 할당 구성을 사용하고 비트 NOT(~) 및 비트 AND(&) 연산자가 있는 표현식을 사용하여 코딩되며 다음 예제와 같습니다.

module nand_gate(input [7:0] a_in, b_in , output [7:0] y_out);
assign y_out = ~(a_in & b_in);
endmodule

2입력 XOR 논리

두 개의 입력 XOR을 배타적 논리합(exclusive OR logic)이라고 하며 두 입력이 같지 않을 때 논리 1로 출력을 생성합니다.

XOR 논리의 진리표

module xor_gate(input a_in, b_in , output reg y_out);
always@(a_in, b_in)
begin
  if ( a_in != b_in )
    y_out = 1;
  else
    y_out = 0;
end
endmodule

다중 입력 XOR 게이트에 대한 RTL은 비트 단위 연산자를 사용하여 코딩됩니다.

module xor_gate ( input [7:0] a_in, b_in , output [7:0] y_out );
assign y_out = (a_in ^ b_in);
endmodule

2입력 XNOR 논리

두 개의 입력 XNOR를 배타적 NOR 논리라고 하며 두 개의 입력이 같을 때 논리 1로 출력을 생성합니다. XNOR는 XOR 논리의 반전입니다.

module xnor_gate(input a_in, b_in , output reg y_out);
always@(a_in, b_in)
begin
  if ( a_in == b_in )
    y_out = 1;
  else
    y_out = 0;
end
endmodule

라이브러리에서 XNOR 게이트를 사용할 수 없는 경우 AND-OR-invert를 사용하거나 최소 수의 NAND 또는 NOR 게이트를 사용하여 XNOR 논리를 실현할 수 있습니다.

다중 입력 XNOR에 대한 RTL은 다음 예제와 같습니다.

module xnor_gate(input [7:0] a_in, b_in , output [7:0] y_out);
assign y_out = (a_in ~^ b_in);
endmodule

tri-state 논리

Tristate에는 논리 0, 논리 1 및 고임피던스 z의 세 가지 논리 상태가 있습니다.

tri-state 버퍼 논리의 진리표

module tri_state_logic ( input [3:0] data_in, input enable, output reg [3:0] data_out );

always@(data_in, enable)
begin
  if (enable)
    data_out = data_in;
  else
    data_out= 4'bZZZZ;
end
endmodule

Verilog 관계 연산자

Verilog는 두 이진수를 비교하는 관계 연산자를 지원하고 두 피연산자를 비교한 후 참('1') 또는 거짓('0') 값을 반환합니다.

다음 표는 관계 연산자를 설명합니다.

module Relational_operators (

input [7:0] a_in,
input [7:0] b_in,
output reg y1_out, y2_out, y3_out, y4_out);

always@ (a_in, b_in )
begin
  // less than < operator
  y1_out = a_in < b_in;
  // less than equal to <= operator
  y2_out = a_in <= b_in;
  // greater than > operator
  y3_out = a_in > b_in;
  // greater than equal to >= operator
  if (a_in >= b_in)
    y4_out = 1;
  else
    y4_out =0;
end
endmodule

Verilog 연결 및 복제 연산자

Verilog는 모든 바이너리 문자열에 대한 집중 및 복제를 지원합니다.

다음 표는 집중 및 복제 연산자의 기능을 설명합니다.

module concatenation_operator (

input [2:0] a_in,
input [2:0] b_in,
output reg [15:0] y_out );
parameter c_in = 3'b010;

always@ (a_in, b_in )
begin
  // use of concatenation{ } and replication n{} operator
  y_out = { a_in, b_in , {3{c_in}}, 3'b111};
end
endmodule

Verilog 감소 연산자

Verilog는 축소 연산자를 지원하고 비트 축소 후 단일 비트 값을 반환합니다.

다음 표는 감소 연산자를 설명합니다.

module reducon_operators (

input [3:0] a_in,
output reg [5:0] y_out);

always@ (a_in)
begin
  // reducon AND
  y_out[0] = & a_in;
  // reducon NAND
  y_out[1] = ~& a_in;
  // reducon OR
  y_out[2] = | a_in;
  // Reducon NOR
  y_out[3] = ~| a_in;
  // Reducon XOR
  y_out[4] = ^ a_in;
  // Reducon XNOR
  y_out[5] = ~^ a_in;
end
endmodule

Verilog 시프트 연산자

Verilog는 시프트 연산자를 사용하며 두 개의 피연산자가 필요합니다. 이 연산자는 이동 작업을 수행하는 데 사용됩니다.

다음 표는 시프트 연산자의 기능을 설명합니다.

module shift_operators (input [3:0] a_in, output reg [3:0] y1_out, y2_out);

parameter b_in = 2;

always@ (a_in)
begin
  // use of left shift operator
  y1_out = a_in << b_in;
  // use of right shift operator
  y2_out = a_in >> b_in;
end
endmodule

Verilog 논리 연산자

Verilog는 원하는 논리 연산을 수행하기 위해 논리 AND, OR 및 부정 연산자를 지원합니다. 논리 연산자는 연산이 끝날 때 단일 비트 값을 반환하는 데 사용됩니다.

다음 표는 논리 연산자의 기능적 사용을 설명합니다.

module logical_operators( input [2:0] a_in, b_in,c_in,d_in,e_in, f_in, output reg y_out );
always@ (a_in, b_in, c_in,d_in,e_in,f_in)
begin
  if ( (a_in < b_in) && ((c_in ==d_in) || (e_in > f_in)))
    y_out = 1;
  else
    y_out =0;
  end
endmodule

Verilog 등식 및 부등식 연산자

Verilog 동등 연산자는 두 피연산자를 비교한 후 참 또는 거짓 값을 반환하는 데 사용됩니다.

다음 표는 연산자의 기능을 설명합니다.

module Equality_operator(

input [7:0] a_in, b_in,
output reg y1_out, y2_out,
output reg [7:0] y3_out );

always@ (a_in, b_in )
begin
  // use of equality operator
  y1_out = (a_in == b_in);

  // use of inequality operator
  y2_out = (a_in != b_in);
 

// use of operator in if condition
 if ( a_in ==b_in)
   y3_out =a_in;
 else
   y3_out = b_in;
 end
endmodule

Verilog 서명 연산자

Verilog는 연산자 양수 '+' 또는 '-'를 지원하여 피연산자에 부호를 할당합니다.

다음 표는 부호 피연산자를 설명합니다.

module sign_operators (

input [1:0] a_in, b_in,
output reg [3:0] y1_out, y2_out
);

always@ (a_in, b_in )
begin
  // use of sign operator
  y1_out = (-a_in) + b_in;

// use of sign operator
y2_out = a_in * (-b_in);

end
endmodule

Verilog 비트 연산자

Verilog는 비트 연산을 지원합니다. 논리 비트 연산자는 두 개의 단일 또는 다중 비트 피연산자를 사용하고 다중 비트 값을 반환합니다. Verilog는 NAND, NOR를 지원하지 않습니다.

다음 표는 비트 연산자의 기능과 사용을 설명합니다.

module bit_wise_operators (

input [6:0] a_in,
input [5:0] b_in,
output reg [6:0] y_out );

always@ (a_in, b_in )
begin
  // bit wise AND
  y_out[0] = a_in[0] & b_in[0];
  // bit wise NAND
  y_out[1] = !( a_in[1] & b_in[1]);
  // bit wise OR
  y_out[2] = a_in[2] | b_in[2];
  // bit wise NOR
  y_out[3] = !( a_in[3] | b_in[3]);
  // bit wise XOR
  y_out[4] = a_in[4] ^ b_in[4];
  // bit wise XNOR
  y_out[5] = ( a_in[5] ~^ b_in[5]);
  // bit wise NOT
  y_out[6] = ! a_in[6];
end
endmodule