Минимизация двоично-десятичного дешифратора на жесткой логике

х1 х2 х3 х4 f
0  0   0   0  0
0  0   0   1  0
0  0   1   0  1
0  0   1   1  1
0  1   0   0  1
0  1   0   1  1
0  1   1   0  1
0  1   1   1  0
1  0   0   0  1
1  0   0   1  1
1  0   1   0  x
1  0   1   1  x
1  1   0   0  x
1  1   0   1  x
1  1   1   0  x
1  1   1   1  x

       x2x1  00  01 11 10
x4x3
       00     0    0   1   1
       01     1    1   0   1
       11     1    1   x   x
       10     x    x   x   x

// Mapping of segment_o lines to actual segments on the display:
//
//        [0]
//       -----
//      |     |
//   [1]|     |[2]
//      | [3] |
//       -----
//      |     |
//   [4]|     |[5]
//      | [6] |
//       -----  o <-----  decimal point [7]
//
//
//  0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
//  -       -   -       -   -   -   -   -   -       -       -   -  
// | |   |   |   | | | |   |     | | | | | | | |   |     | |   |    
//          -   -   -   -   -       -   -   -   -       -   -   -   
// | |   | |     |   |   | | |   | | |   | | | | | |   | | |   |   
//  -       -   -       -   -       -   -       -   -   -   -      
 
 
module led_display_driver (
  clk_i,
  ce_i,
  rst_i,
  data_i,
  point_i,
  digit_on_i,
  segment_o,
  common_o
  );
// Timer defaults set up for 1MHz clock
parameter DIGITS_PP        = 4;     // # of digits in LED display.
parameter DUTY_CYCLE_PP    = 8;     // # of digit timeslots
parameter SEGMENT_DRIVE_PP = 0;     // 0 = sink from segments (Common Anode)
                                    // 1 = source to segments (Common Cathode)
parameter COMMON_DRIVE_PP  = 1;     // 0 = 1 common low, others high
                                    // 1 = 1 common high, others low
parameter DIGIT_TIMEOUT_PP = 512;   // Clock cycles per digit timeslot
parameter DIGIT_TIMER_WIDTH_PP = 9; // Bit width of digit timer
parameter DIGIT_COUNT_WIDTH_PP = 3; // Bit width of digit counter
 
// I/O declarations
input  clk_i;                      // clock signal
input  ce_i;                       // clock enable input
input  rst_i;                      // synchronous reset
input  [4*DIGITS_PP-1:0] data_i;   // data input bus
input  [DIGITS_PP-1:0] point_i;    // Decimal point input bus
input  [DIGITS_PP-1:0] digit_on_i; // Polarity of common_o...
output [7:0] segment_o;            // (includes decimal point segment)
output [DIGITS_PP-1:0] common_o;   // One output per display digit...
 
 
// Internal signal declarations
 
reg [DIGIT_TIMER_WIDTH_PP-1:0] digit_timer;
reg [DIGIT_COUNT_WIDTH_PP-1:0] digit_count;
 
wire digit_clk_en;
wire [3:0] hex_digit;
reg  [6:0] number_segments;
wire decimal_point;
 
//--------------------------------------------------------------------------
// Module code
 
 
//----------MUX part-----------------------------------
 
assign hex_digit = data_i >> {digit_count,2'b0};
assign decimal_point = point_i >> digit_count;
 
 
// Digit timer
always @(posedge clk_i)
begin
  if (rst_i) digit_timer <= 0;  // Synchronous reset
  else if (ce_i)
  begin
    if (digit_timer == DIGIT_TIMEOUT_PP-1) digit_timer <=0;
    else digit_timer <= digit_timer + 1;
  end
end
assign digit_clk_en = (digit_timer == DIGIT_TIMEOUT_PP-1) && ce_i;
 
// Digit counter
always @(posedge clk_i)
begin
  if (rst_i) digit_count <=0;  // Synchronous reset
  else if (digit_clk_en)
  begin
    if (digit_count == DUTY_CYCLE_PP-1) digit_count <= 0;
    else digit_count <= digit_count + 1;
  end
end
 
// Create common_o outputs
// One high... then selectively invert.
assign common_o = (COMMON_DRIVE_PP==1'b1)?
                     ((1'b1 << digit_count) & digit_on_i):
                    ~((1'b1 << digit_count) & digit_on_i);
 
// Create segment outputs
always @(hex_digit)
begin
  case(hex_digit)
    4'h0 : number_segments <= 7'b1110111;
    4'h1 : number_segments <= 7'b0100100;
    4'h2 : number_segments <= 7'b1011101;
    4'h3 : number_segments <= 7'b1101101;
    4'h4 : number_segments <= 7'b0101110;
    4'h5 : number_segments <= 7'b1101011;
    4'h6 : number_segments <= 7'b1111011;
    4'h7 : number_segments <= 7'b0100101;
    4'h8 : number_segments <= 7'b1111111;
    4'h9 : number_segments <= 7'b1101111;
    4'hA : number_segments <= 7'b0111111;
    4'hB : number_segments <= 7'b1111010;
    4'hC : number_segments <= 7'b1010011;
    4'hD : number_segments <= 7'b1111100;
    4'hE : number_segments <= 7'b1011011;
    4'hF : number_segments <= 7'b0011011;
  endcase
end
 
// Assign final polarity adjusted segment outputs
assign segment_o = (SEGMENT_DRIVE_PP==1'b1)? {decimal_point,number_segments}:
                                            ~{decimal_point,number_segments};
 
endmodule