FSM Implementierung eines Entprellschaltung in Verilog (Fehler in der Zeit Zecke)

Question

Ich brauche ein Problem in FPGA-Prototyping von Verilog Beispiele zu lösen Pong

Wenn sein Autor Fehler oder ich etw falsch tun, wenn ich auf simulieren vivado ich finde keine Änderung in

q_reg <= q_next; // ? q_next never initialised ??? 
    // next-state logic // How he wants to set time tick ? 
    assign q_next = q_reg + 1; 
    // output tick 

Zustandsdiagramm einer Entprellung Schaltung. als Bild definiert ist

Abschnitt
// Zähler betrachten zu erzeugen 10 ms

module db_fsm 
    (
    input wire clk, reset, 
    input wire sw, 
    output reg db 
    ); 

    // symbolic state declaration 
    localparam [2:0] 
       zero = 3'b000, 
       wait1_1 = 3'b001, 
       wait1_2 = 3'b010, 
       wait1_3 = 3'b011, 
       one  = 3'b100, 
       wait0_1 = 3'b101, 
       wait0_2 = 3'b110, 
       wait0_3 = 3'b111; 

    // number of counter bits (2^N * 20ns = 10ms tick) 
    localparam N =19; 

    // signal declaration 
    reg [N-1:0] q_reg; 
    wire [N-1:0] q_next; 
    wire m_tick; 
    reg [2:0] state_reg, state_next; 

    // body 

    //============================================= 
    // counter to generate 10 ms tick 
    //============================================= 
    always @(posedge clk) 
     q_reg <= q_next; 
    // next-state logic 
    assign q_next = q_reg + 1; 
    // output tick 
    assign m_tick = (q_reg==0) ? 1'b1 : 1'b0; 

    //============================================= 
    // debouncing FSM 
    //============================================= 
    // state register 
    always @(posedge clk, posedge reset) 
     if (reset) 
      state_reg <= zero; 
     else 
      state_reg <= state_next; 

    // next-state logic and output logic 
    always @* 
    begin 
     state_next = state_reg; // default state: the same 
     db = 1'b0;    // default output: 0 
     case (state_reg) 
     zero: 
      if (sw) 
       state_next = wait1_1; 
     wait1_1: 
      if (~sw) 
       state_next = zero; 
      else 
       if (m_tick) 
        state_next = wait1_2; 
     wait1_2: 
      if (~sw) 
       state_next = zero; 
      else 
       if (m_tick) 
        state_next = wait1_3; 
     wait1_3: 
      if (~sw) 
       state_next = zero; 
      else 
       if (m_tick) 
        state_next = one; 
     one: 
      begin 
       db = 1'b1; 
       if (~sw) 
       state_next = wait0_1; 
      end 
     wait0_1: 
      begin 
       db = 1'b1; 
       if (sw) 
        state_next = one; 
       else 
       if (m_tick) 
        state_next = wait0_2; 
      end 
     wait0_2: 
      begin 
       db = 1'b1; 
       if (sw) 
        state_next = one; 
       else 
       if (m_tick) 
        state_next = wait0_3; 
      end 
     wait0_3: 
      begin 
       db = 1'b1; 
       if (sw) 
        state_next = one; 
       else 
       if (m_tick) 
        state_next = zero; 
      end 
     default: state_next = zero; 
     endcase 
    end 

endmodule 

Answer 1

q_next nicht initialisiert tick werden muss, ist es eine kombinatorische Logik aus q_reg abgeleitet. q_reg ist nicht explizit initialisiert, daher wird der Standardwert verwendet.

Der Standardwert eines Flops auf FPGA ist 0, aber für Simulatoren ist der Standardwert X. Der Grund für diese Diskrepanz liegt darin, dass Verilog auch zur Simulation integrierter Schaltungen (IC) verwendet wird; die Flops können einen Anfangswert hat, der aufgrund des Technologieknoten zufällig scheint, Herstellungsverfahren und Variationen, Temperatur usw.

Da Ihr Ziel ist FGPA, die einfache Lösung ist es, die Linie initial q_reg = {N{1'b0}}; oder ändern reg [N-1:0] q_reg;-reg [N-1:0] q_reg = {N{1'b0}}; Entweder hinzufügen Art der Initialisierung q_reg wird Sie Verilog Simulation und FPGA-Abgleich haben.

BTW: für eine ASIC als das Ziel wird die FPGA-Lösung nicht funktionieren (Initialisierung wird von ASIC-Synthesizern ignoriert). Eine ASIC-Lösung würde eine Rücksetzbedingung (synchron oder asynchron) zu dem always-Block hinzufügen, der den Flop zuweist. Die ASIC-Lösung funktioniert für FPGA, FPGAs haben jedoch eine begrenzte Anzahl (falls vorhanden) von Flops mit asynchronem Reset/set