Verilog Help

Discussion in 'Programmer's Corner' started by Aqual, Nov 5, 2011.

  1. Aqual

    Thread Starter New Member

    Nov 5, 2011
    1
    0
    I have been working at this code for hours now and can't seem to figure out my mistake. Essentially, the code acts as a 4-bit binary to BCD converter. After the final value of each digit has been determined, it is sent to a module to print it out on a 7-segment display using cathode and anode. Behaviorally, the modules work fine. However, once translated, the code breaks down. A post-translation simulation reveals that "state" from the main module is being recognized as a 3-bit array, instead of 2. Any and all help is greatly appreciated.

    Here is the main module

    Code ( (Unknown Language)):
    1.  
    2. module Binary_Display
    3.     (input CLK_50M,
    4.     input [7:0] switches,
    5.     input reset,
    6.     output [6:0] cathode,
    7.     output [3:0] anode);
    8.    
    9.     parameter [1:0]     CLEAR = 2'b00,
    10.                             SHIFT = 2'b01,
    11.                             ADD_3 = 2'b10;
    12.                    
    13.     wire mili_clk;
    14.     reg [1:0] state, next = 0;
    15.     reg [7:0] switch_temp, binary;
    16.     reg [3:0] hundreds, tens, ones, hfinal, tfinal, ofinal;
    17.     reg [3:0] shift_counter;
    18.    
    19.     Top_Module clock
    20.     (.CLK_50M(CLK_50M),
    21.     .reset(reset),
    22.     .Milli_sec_clock(mili_clk));
    23.    
    24.     Display control
    25.     (.clk_mili(mili_clk),
    26.     .hundreds(hfinal),
    27.     .tens(tfinal),
    28.     .ones(ofinal),
    29.     .reset(reset),
    30.     .anode(anode),
    31.     .cathode(cathode));
    32.    
    33.     always @ (posedge CLK_50M or posedge reset) begin
    34.         if (reset) begin
    35.             state <= CLEAR;
    36.         end else if (switch_temp != switches) begin
    37.             state <= CLEAR;
    38.         end else begin
    39.             state <= next;
    40.         end
    41.     end
    42.    
    43.     always @* begin
    44.         next = state;
    45.         case (state)
    46.             CLEAR:    begin
    47.                             switch_temp = switches;
    48.                             shift_counter = 0;
    49.                             hundreds = 0;
    50.                             tens = 0;
    51.                             ones = 0;
    52.                             binary = switches;
    53.                             next = SHIFT;
    54.                         end
    55.             SHIFT:    begin
    56.                             hundreds = {hundreds[2:0], tens[3]};
    57.                             tens = {tens[2:0], ones[3]};
    58.                             ones = {ones[2:0], binary[7]};
    59.                             binary = {binary[6:0], 1'b0};
    60.                             shift_counter = shift_counter + 1;
    61.                             next = ADD_3;
    62.                         end
    63.             ADD_3:    begin
    64.                             if (shift_counter == 8) begin
    65.                                 hfinal = hundreds;
    66.                                 tfinal = tens;
    67.                                 ofinal = ones;
    68.                                 next = CLEAR;
    69.                             end
    70.                             else begin
    71.                                 if (hundreds > 4) begin
    72.                                     hundreds = hundreds + 3;
    73.                                 end
    74.                                 if (tens > 4) begin
    75.                                     tens = tens + 3;
    76.                                 end
    77.                                 if (ones > 4) begin
    78.                                     ones = ones + 3;
    79.                                 end
    80.                                 next = SHIFT;
    81.                             end
    82.                         end
    83.             default: next = CLEAR;
    84.         endcase
    85.     end
    86. endmodule
    87.  
    88.  
    89. here is the module for determining cathode and anode
    90.  
    91. module Display
    92.     (input clk_mili,
    93.     input [3:0] hundreds,
    94.     input [3:0] tens,
    95.     input [3:0] ones,
    96.     input reset,
    97.     output reg [3:0] anode,
    98.     output reg [6:0] cathode);
    99.    
    100.     parameter [2:0]    state1 = 3'b000,
    101.                             state2 = 3'b001,
    102.                             state3 = 3'b010,
    103.                             state4 = 3'b011,
    104.                             state5 = 3'b100;
    105.                    
    106.     reg [2:0] state, next;
    107.     reg [3:0] T1;
    108.     reg [6:0] temp1;
    109.    
    110.     always@ (posedge clk_mili or posedge reset) begin
    111.         if (reset) begin
    112.             state <= state1;
    113.         end else begin
    114.             state <= next;
    115.         end
    116.     end
    117.    
    118.     always@ * begin
    119.         case (state)
    120.             state1:    begin
    121.                             cathode = 1;
    122.                             anode = 0;
    123.                             next = state2;
    124.                         end
    125.             state2:    begin
    126.                             anode = 4'b1110;
    127.                             T1 = ones;
    128.                             case (T1)
    129.                                 0: temp1 = 7'b0000001;
    130.                                 1:    temp1 = 7'b1001111;
    131.                                 2: temp1 = 7'b0010010;
    132.                                 3:    temp1 = 7'b0000110;
    133.                                 4:    temp1 = 7'b1001100;
    134.                                 5:    temp1 = 7'b0100100;
    135.                                 6:    temp1 = 7'b0100000;
    136.                                 7: temp1 = 7'b0001111;
    137.                                 8: temp1 = 7'b0000000;
    138.                                 9: temp1 = 7'b0000100;
    139.                                 10: temp1 = 7'b0001000;
    140.                                 11: temp1 = 7'b1100000;
    141.                                 12: temp1 = 7'b0110001;
    142.                                 13: temp1 = 7'b1000010;
    143.                                 14: temp1 = 7'b0110000;
    144.                                 15: temp1 = 7'b0111000;
    145.                             endcase
    146.                             cathode = temp1;
    147.                             next = state3;
    148.                         end
    149.             state3:    begin
    150.                             anode = 4'b1101;
    151.                             T1 = tens;
    152.                             case (T1)
    153.                                 0: temp1 = 7'b0000001;
    154.                                 1:    temp1 = 7'b1001111;
    155.                                 2: temp1 = 7'b0010010;
    156.                                 3:    temp1 = 7'b0000110;
    157.                                 4:    temp1 = 7'b1001100;
    158.                                 5:    temp1 = 7'b0100100;
    159.                                 6:    temp1 = 7'b0100000;
    160.                                 7: temp1 = 7'b0001111;
    161.                                 8: temp1 = 7'b0000000;
    162.                                 9: temp1 = 7'b0000100;
    163.                                 10: temp1 = 7'b0001000;
    164.                                 11: temp1 = 7'b1100000;
    165.                                 12: temp1 = 7'b0110001;
    166.                                 13: temp1 = 7'b1000010;
    167.                                 14: temp1 = 7'b0110000;
    168.                                 15: temp1 = 7'b0111000;
    169.                             endcase
    170.                             cathode = temp1;
    171.                             next = state4;
    172.                         end
    173.             state4:    begin
    174.                             anode = 4'b1011;
    175.                             T1 = hundreds;
    176.                             case (T1)
    177.                                 0: temp1 = 7'b0000001;
    178.                                 1:    temp1 = 7'b1001111;
    179.                                 2: temp1 = 7'b0010010;
    180.                                 3:    temp1 = 7'b0000110;
    181.                                 4:    temp1 = 7'b1001100;
    182.                                 5:    temp1 = 7'b0100100;
    183.                                 6:    temp1 = 7'b0100000;
    184.                                 7: temp1 = 7'b0001111;
    185.                                 8: temp1 = 7'b0000000;
    186.                                 9: temp1 = 7'b0000100;
    187.                                 10: temp1 = 7'b0001000;
    188.                                 11: temp1 = 7'b1100000;
    189.                                 12: temp1 = 7'b0110001;
    190.                                 13: temp1 = 7'b1000010;
    191.                                 14: temp1 = 7'b0110000;
    192.                                 15: temp1 = 7'b0111000;
    193.                             endcase
    194.                             cathode = temp1;
    195.                             next = state5;
    196.                         end
    197.             state5:    begin
    198.                             anode = 4'b0111;
    199.                             cathode = 1;
    200.                             next = state2;
    201.                         end
    202.             3'b101:    next = state1;
    203.             3'b110:    next = state1;
    204.             3'b111:    next = state1;
    205.             default: next = state1;
    206.         endcase
    207.     end
    208. endmodule
    209.  
    210. and finally, here is a module that is used to generate a 1 millisecond clock
    211.  
    212. module Top_Module
    213.     (input CLK_50M,
    214.     input reset,
    215.     output reg Milli_sec_clock);
    216.    
    217.     reg [14:0] counter = 0;
    218.        
    219.     always @ (posedge CLK_50M or posedge reset) begin
    220.         if (reset) begin
    221.             Milli_sec_clock <= 0;
    222.             counter <= 1;
    223.         end else begin
    224.             if (counter == 25000) begin
    225.                 Milli_sec_clock <= ~Milli_sec_clock;
    226.                 counter <= 1;
    227.             end else if (counter == 0) begin
    228.                 Milli_sec_clock <= 0;
    229.                 counter <= 1;
    230.             end else begin
    231.                 counter <= counter + 1;
    232.             end
    233.         end
    234.     end
    235. endmodule
    236.  
     
    Last edited by a moderator: Nov 6, 2011
  2. guitarguy12387

    Active Member

    Apr 10, 2008
    359
    12
    Is it possible for you to post some results? Simulation results? Explanation of 'the code breaks down' ?

    I have a few comments though:

    This is probably because it's using one-hot encoding by default. Most FPGA tools will do this because one-hot encoding is faster in FPGAs and it's practically free (FPGAs have loads of flip flops).

    Also, un-synchronized asynchronous resets are discouraged in FPGAs. They are VERY rarely necessary.

    Also, you have a lot of latches in this design (also poor FPGA design practice). Your output signals should all be assigned in every single state. The easy way to do that is with default assignments.
     
Loading...