Verilog Tutorial 3 - ModelSim - BCD Incrementor

Binary Coded Decimal (BCD) is a class of binary encoding of decimal numbers where each decimal digit is represented by a fixed number of bits, usually four or eight^[1]. BCD is also called "8421" encoding. This is the truth table of BCD encoding, where each decimal digits is represented by its corresponding 4-bit binary value:

For example, 168₁₀ (10101000₂) is represented as "0001 0110 1000" in BCD format. In this tutorial, I will implementing a digital circuit for adds 1 to a number in BCD format. The BCD format is three-digit decimal number (12-bit). For example, after incrementing, "0010 0101 1001" (259₁₀) becomes "0010 0110 0000" (260₁₀).

This is the top level schematic for three-digit BCD incrementor. This circuit is actually consist of three 4-bit incrementor module. 4-bit incrementor has input signal of BCD number and output signal of incremented BCD number. There is also a carry output signal that give indication when an incremented BCD number rollover (from 9₁₀ (1001₂) to 0₁₀ (0000₂)). In the three-digit incrementor circuit, this carry signal is used for give a signal to the next 4-bit incrementor module to increment the digit.

This is the code for 4-bit incrementor using behavioral description:

// bcd_incrementer.v
module bcd_incrementer
    (
        input wire [3:0] in,
        input wire en,
        output reg [3:0] out,
        output reg carry
    );

    // Body
    always @*
    begin
        out = in;
        carry = 1'b0;
        case ({en, in[3:0]})
            5'b10000: out = 4'b0001;
            5'b10001: out = 4'b0010;
            5'b10010: out = 4'b0011;
            5'b10011: out = 4'b0100;
            5'b10100: out = 4'b0101;
            5'b10101: out = 4'b0110;
            5'b10110: out = 4'b0111;
            5'b10111: out = 4'b1000;
            5'b11000: out = 4'b1001;
            5'b11001: 
                    begin
                        out = 4'b0000; 
                        carry = 1'b1;
                    end
        endcase
    end

endmodule

This is the code for top module of three-digit BCD incrementor:

// top.v
module top
    (
        input wire [11:0] in,
        input wire en,
        output wire [11:0] out,
        output wire ovf 
    );

    // Signal declaration
    wire c1, c2;

    // Body
    bcd_incrementer bcd_incrementer_digit_1_unit
        (.in(in[3:0]), .en(en), .out(out[3:0]), .carry(c1));
 
    bcd_incrementer bcd_incrementer_digit_2_unit
        (.in(in[7:4]), .en(c1), .out(out[7:4]), .carry(c2)); 

    bcd_incrementer bcd_incrementer_digit_3_unit
        (.in(in[11:8]), .en(c2), .out(out[11:8]), .carry(ovf));  
 
endmodule

This is the code for verify the circuit operation:

// top_tb.v
`timescale 1 ns/ 10 ps

module top_tb;
    // Signal declaration 
    reg [11:0] in_test;
    reg en_test;
    wire [11:0] out_test;
    wire ovf_test;

    // Instantiate the circuit under test
    top uut (.in(in_test), .en(en_test), .out(out_test), .ovf(ovf_test));
 
    // Test vector generator
    initial
    begin
        en_test = 1'b0;

        in_test = 12'b000000000000; // 000
        # 200;
        in_test = 12'b000000000011; // 003
        # 200;
        in_test = 12'b000000100011; // 023
        # 200;
        in_test = 12'b000100100011; // 123
        # 200;
        in_test = 12'b000100101001; // 129
        # 200;
        in_test = 12'b000110010011; // 193
        # 200;
        in_test = 12'b100100100011; // 923
        # 200;
        in_test = 12'b000010011001; // 099
        # 200;
        in_test = 12'b100100001001; // 909
        # 200;
        in_test = 12'b100110010000; // 990
        # 200;
        in_test = 12'b100110011001; // 999
        # 200;

        en_test = 1'b1;

        in_test = 12'b000000000000; // 000
        # 200;
        in_test = 12'b000000000011; // 003
        # 200;
        in_test = 12'b000000100011; // 023
        # 200;
        in_test = 12'b000100100011; // 123
        # 200;
        in_test = 12'b000100101001; // 129
        # 200;
        in_test = 12'b000110010011; // 193
        # 200;
        in_test = 12'b100100100011; // 923
        # 200;
        in_test = 12'b000010011001; // 099
        # 200;
        in_test = 12'b100100001001; // 909
        # 200;
        in_test = 12'b100110010000; // 990
        # 200;
        in_test = 12'b100110011001; // 999
        # 200;

        // Stop simulation
        $stop;
    end
 
endmodule

This is the waveform result from three-digit BCD incrementor:

You can download the project file for this circuit from my repository. This tutorial is based on FPGA Prorotyping by Verilog Example book by Pong P. Chu. This book is recommended for learning FPGA through practical example.

References:
^[1] https://en.wikipedia.org/wiki/Binary-coded_decimal