Verilog - Combination Logic code(half adder,full adder,comparator,decoder)조합논리회로

 

 

반가산기

 

 

전가산기

 

 

 

4bit 전가산기

 

 

4bit Full Subtractor

 

 

Comparator

 

 

2x4 디코더

 

 

 

enable 신호가 들어올 때 동작하는 decoder

 

 

3x8 decoder

 

 

4x16 decoder

`timescale 1ns / 1ps

// 반가산기 모듈 정의
module half_adder(
    input a, b,         // 입력 비트
    output sum, carry   // 합과 자리올림 비트 출력
);
    assign sum = a ^ b; // XOR 연산을 통한 합
    assign carry = a & b; // AND 연산을 통한 자리올림
endmodule

// 반가산기 동작 모델링
module halfadder_behaviors(
    input a, b,         // 입력 비트
    output reg s, c     // reg 선언을 통한 동작 모델링
);
    always @(a, b) begin
        case ({a, b})
            2'b00: begin s = 0; c = 0; end
            2'b01: begin s = 1; c = 0; end
            2'b10: begin s = 1; c = 0; end
            2'b11: begin s = 0; c = 1; end
        endcase
    end
endmodule

// 전가산기 구조적 모델링
module fulladder_structural(
    input a, b, cin,    // 입력 비트와 자리올림 입력
    output sum, carry   // 합과 자리올림 비트 출력
);
    wire sum_0, carry_0, carry_1; // 내부 와이어 선언

    // 반가산기 인스턴스화
    half_adder ha0 (.a(a), .b(b), .sum(sum_0), .carry(carry_0));
    half_adder ha1 (.a(sum_0), .b(cin), .sum(sum), .carry(carry_1));

    // OR 게이트를 통한 자리올림 계산
    or(carry, carry_0, carry_1);
endmodule

// 전가산기 데이터 모델링
module full_adder(
    input a, b, cin,    // 입력 비트와 자리올림 입력
    output sum, carry   // 합과 자리올림 비트 출력
);
    assign #2 sum = a ^ b ^ cin; // XOR 연산을 통한 합
    assign #3 carry = (cin & (a ^ b)) | (a & b); // AND, OR 연산을 통한 자리올림
endmodule

// 4비트 가산기 구조적 모델링
module fadder_4bit_s(
    input [3:0] a, b,   // 4비트 입력
    input cin,          // 자리올림 입력
    output [3:0] sum,    // 4비트 합 출력
    output carry        // 출력 자리올림
);
    wire [2:0] carry_in; // 내부 와이어 선언

    // 전가산기 인스턴스화
    full_adder fa0 (.a(a[0]), .b(b[0]), .cin(cin), .sum(sum[0]), .carry(carry_in[0]));
    full_adder fa1 (.a(a[1]), .b(b[1]), .cin(carry_in[0]), .sum(sum[1]), .carry(carry_in[1]));
    full_adder fa2 (.a(a[2]), .b(b[2]), .cin(carry_in[1]), .sum(sum[2]), .carry(carry_in[2]));
    full_adder fa3 (.a(a[3]), .b(b[3]), .cin(carry_in[2]), .sum(sum[3]), .carry(carry));

endmodule

// 4비트 가산기 데이터 모델링
module fadder_4bit(
    input [3:0] a, b,   // 4비트 입력
    input cin,          // 자리올림 입력
    output [3:0] sum,    // 4비트 합 출력
    output carry        // 출력 자리올림
);
    wire [4:0] temp;     // 내부 와이어 선언

    // 합과 자리올림 계산
    assign temp = a + b + cin;
    assign sum = temp[3:0];
    assign carry = temp[4];

endmodule

// 4비트 가산기/뺄셈 구조적 모델링
module fadd_sub_4bit_s(
    input [3:0] a, b,   // 4비트 입력
    input s,            // 덧셈(0) 또는 뺄셈(1) 선택 신호
    output [3:0] sum,   // 4비트 합 출력
    output carry        // 출력 자리올림
);
    wire [2:0] carry_in; // 내부 와이어 선언

    // 전가산기 인스턴스화
    full_adder fa0 (.a(a[0]), .b(b[0] ^ s), .cin(s), .sum(sum[0]), .carry(carry_in[0]));
    full_adder fa1 (.a(a[1]), .b(b[1] ^ s), .cin(carry_in[0]), .sum(sum[1]), .carry(carry_in[1]));
    full_adder fa2 (.a(a[2]), .b(b[2] ^ s), .cin(carry_in[1]), .sum(sum[2]), .carry(carry_in[2]));
    full_adder fa3 (.a(a[3]), .b(b[3] ^ s), .cin(carry_in[2]), .sum(sum[3]), .carry(carry));

endmodule

// 4비트 가산기/뺄셈 데이터 모델링
module fadd_sub_4bit(
    input [3:0] a, b,   // 4비트 입력
    input s,            // 덧셈(0) 또는 뺄셈(1) 선택 신호
    output [3:0] sum,   // 4비트 합 출력
    output carry        // 출력 자리올림
);
    wire [4:0] temp;     // 내부 와이어 선언

    // 덧셈 또는 뺄셈 결과 계산
    assign temp = s ? a - b : a + b;
    assign sum = temp[3:0];
    assign carry = temp[4];

endmodule

// 4비트 비교기 모듈 정의
module comparator #(parameter N = 4)(
    input [N-1:0] a, b,       // 비교할 입력 비트
    output equal, greater, less // 결과 비트 출력
);
    // 결과 비교
    assign equal = (a == b) ? 1'b1 : 1'b0;
    assign greater = (a > b) ? 1'b1 : 1'b0;
    assign less = (a < b) ? 1'b1 : 1'b0;

endmodule

// 2-4 디코더 (case 문 사용)
module decoder_2_4_case(
    input [1:0] a,    // 2비트 입력
    output reg [3:0] y // 4비트 출력
);
    always @(a) begin
        case (a)
            2'b00: y = 4'b0001;
            2'b01: y = 4'b0010;
            2'b10: y = 4'b0100;
            2'b11: y = 4'b1000;
        endcase
    end
endmodule

// 2-4 디코더 (if 문 사용)
module decoder_2_4_if(
    input [1:0] a,    // 2비트 입력
    output reg [3:0] y // 4비트 출력
);
    always @(a) begin
        if (a == 2'b00) y = 4'b0001;
        else if (a == 2'b01) y = 4'b0010;
        else if (a == 2'b10) y = 4'b0100;
        else y = 4'b1000;
    end
endmodule

// 2-4 디코더 (data flow)
module decoder_2_4(
    input [1:0] a,    // 2비트 입력
    output [3:0] y    // 4비트 출력
);
    // 조건 연산자를 통한 디코딩
    assign y = (a == 2'b00) ? 4'b0001 : (a == 2'b01) ? 4'b0010 : (a == 2'b10) ? 4'b0100 : 4'b1000;

endmodule

// 2-4 디코더 (enable 기능 추가)
module decoder_2_4_en(
    input [1:0] a,    // 2비트 입력
    input en,         // 활성화 신호
    output [3:0] y    // 4비트 출력
);
    // 활성화 신호에 따라 출력 결정
    assign y = (~en) ? 4'b0000 : (a == 2'b00) ? 4'b0001 : (a == 2'b01) ? 4'b0010 : (a == 2'b10) ? 4'b0100 : 4'b1000;

endmodule

// 3-8 디코더 (enable 기능 추가)
module decoder_3_8_1(
    input [2:0] a,    // 3비트 입력
    input en,         // 활성화 신호
    output reg [7:0] y // 8비트 출력
);

    always @(a) begin
        if (en) begin
            case (a)
                3'b000: y = 8'b0000_0001;
                3'b001: y = 8'b0000_0010;
                3'b010: y = 8'b0000_0100;
                3'b011: y = 8'b0000_1000;
                3'b100: y = 8'b0001_0000;
                3'b101: y = 8'b0010_0000;
                3'b110: y = 8'b0100_0000;
                3'b111: y = 8'b1000_0000;
            endcase
        end
        else
            y = 0;
    end
endmodule

// 4-16 디코더 (enable 기능 추가)
module decoder_4_16_1(
    input en,          // 활성화 신호
    input [3:0] a,      // 4비트 입력
    output [15:0] y     // 16비트 출력
);
    wire [7:0] y1;        // 내부 와이어 선언
    wire [15:8] y2;       // 내부 와이어 선언
    assign y = (en == 1'b1) ? ({y1, 8'b0}) : ({8'b0, y2});
    // 하위 8비트 디코더
    decoder_3_8_1 copy1 (.a(a), .y(y1));
    // 상위 8비트 디코더
    decoder_3_8_1 copy2 (.a(a), .y(y2));
endmodule