Erste Gehversuche Verilog

[T. F. (sar)]

Hi,

Ich probiere gerade folgendes in Verilog auf einem Lattice FPGA zu 
realisieren.

Ich habe einen Eingang, sync_in, und wenn dieser von high auf low 
wechselt, möchte ich einen Zähler starten. Der Zähler soll dann weiter 
inkrementieren bis er einen maximalen Wert erreicht. Dann soll der 
Zähler auf 0 zurück gesetzt werden und bis auf die nächste fallende 
Flanke warten.

Ich habe bis jetzt mit VHDL zu tun gehabt und probiere in einem anderen 
Projekt eine kleine Änderung durchzuführen: Der Zähler zuvor rannte 
einfach von 0 auf max und fing dann wieder bei 0 an.

Mit folgendem Konstrukt erhalte ich fast das gewünschte Verhalten, 
allerdings scheint cnt zwischen Wert 0 und StopValue-1 hin und her zu 
wackeln, wenn keine Flanke von sync_in kommt. Ich komme mit Lattice 
Diamond irgendwie noch nicht klar und bekomme keine Simulation dafür 
hin. Gepaart mit meinem Verilog Verständnis komme ich derzeit nicht 
weiter.

Hier der Code:

wire      reset_sw_n;
reg        sync_in_r, sync_in_r1;
reg        start_load;
reg  [12:0]    cnt;

// synchronize sync signal
always @(posedge clk)
begin
  sync_in_r <= sync_in;
end

always @(posedge clk)
begin
  sync_in_r1 <= sync_in_r;
end

// the counter
always  @(posedge clk or negedge reset_sw_n)
begin
  // reset count value and start_load
  if(~reset_sw_n)
  begin
    cnt  <= #1 13'd0;  
    start_load <= 1'b0;
  end
  // if sync_in_r1 = low and sync_in_r = 1 we have a falling edge, set start_load = 1
  else if(sync_in_r1 == 1'b0)
    if (sync_in_r == 1'b1)
      start_load <= #1 1'b1;
  // if start_load = 1, increase counter. When StopValue is reached set start_load = 0 and count value to zero
  else if (start_load == 1'b1)
    begin
    if (cnt == StopValue)
      begin        
        start_load <= 1'b0;
        cnt  <= #1 13'd0;
      end
    else
      cnt  <= #1 cnt + 1'b1;
    end  
end

Hoffe ihr könnt mir weiter helfen.

Danke

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Ich kann zwar auch kein Verilog aber wenn diese #1 symbolische 
Verzögerungen in einer Verhaltensbeschreibung sind, dann lass die mal 
weg...

[Christoph db1uq K. (christoph_kessler)]

Ich kannte diese Formulierung mit # nicht, im verlinkten Wikiartikel 
steht dazu:
"Vielleicht ist es ganz sinnvoll, an dieser Stelle nochmal zu erwähnen, 
dass das Verzögerungszeichen nicht synthetisierbar ist."
Verzögerungen muss man schon explizit erstellen, einen Zähler und dann 
die Verknüpfung damit.

[Cle (Gast)]

Christoph K. schrieb:
> Ich kannte diese Formulierung mit # nicht, im verlinkten
> Wikiartikel
> steht dazu:
> "Vielleicht ist es ganz sinnvoll, an dieser Stelle nochmal zu erwähnen,
> dass das Verzögerungszeichen nicht synthetisierbar ist."
> Verzögerungen muss man schon explizit erstellen, einen Zähler und dann
> die Verknüpfung damit.

Ohne zu wissen was sich der TO gedacht hat, ich kenne die Pounddelays 
für die Simulation. Bei der Sythese werden diese dann ignoriert, muss 
daher kein Problem sein. Das verzögert das Signal in der Simulation nur 
um einen Tick.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Cle schrieb:
> Das verzögert das Signal in der Simulation nur um einen Tick.
Eben das kann in der Simulation diesen seltsamen Effekt auslösen. Was 
ist denn in der Verilog Simulation die kürzeste Verzögerung? Und was ist 
der Simulationstakt? Hängen die irgendwie zusammen?

Kurz: in eine Verhaltensbeschreibung kommt keine Verzögerung.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

T. F. schrieb:
> Ich komme mit Lattice Diamond irgendwie noch nicht klar und bekomme
> keine Simulation dafür hin.
Also doch keine Simulation...
Zum Simulieren verwendest du bei Lattice den Aldec Simulator. Der ist 
eigenständig und du musst damit ein eigenes Simulationsprojekt 
aufsetzen, das im Idealfall einfach die selben Sourcedateien wie Diamond 
verwendet und denen eine Testbench hinzufügt.

[bko (Gast)]

habe mal ein paar mehr begin-end Paare eingebaut, nun tut der code etwas 
anderes, wenn zweimal hindereinander "if" dann weiß ich nicht zu welchem 
der "if"s das "else" dann gehört ... (aber so richtig 100% kann ich 
verilog auch nicht!)

Simulieren kann man auch mit "http://iverilog.icarus.com/"; + ansehen mit 
http://gtkwave.sourceforge.net/

        
`default_nettype none

module testcnt(input clk, input sync_in,input reset_sw_n,
                      input [12:0] StopValue);

wire      reset_sw_n;
reg        sync_in_r, sync_in_r1;
reg        start_load;
reg  [12:0]    cnt = 0;

// synchronize sync signal
always @(posedge clk)
begin
  sync_in_r <= sync_in;
end

always @(posedge clk)
begin
  sync_in_r1 <= sync_in_r;
end

// the counter
always  @(posedge clk or negedge reset_sw_n)
begin
  // reset count value and start_load
  if(~reset_sw_n)
    begin
    cnt  <= #1 13'd0;  
    start_load <= 1'b0;
    end
  // if sync_in_r1 = low and sync_in_r = 1 we have a falling edge, set start_load = 1
  else
     begin 
     if(sync_in_r1 == 1'b0)
        begin
        if (sync_in_r == 1'b1)
          start_load <= #1 1'b1;
        end
     // if start_load = 1, increase counter. When StopValue is reached set start_load = 0 and count value to zero
     else 
     begin
     if (start_load == 1'b1)
        begin
           if (cnt == StopValue)
             begin        
               start_load <= 1'b0;
               cnt  <= #1 13'd0;
             end
              else
                cnt  <= #1 cnt + 1'b1;
           end 
        end
     end  
end

endmodule

[Frank S. (schroederde)]

`timescale 1ns / 1ns

module TiefpassTrigger
(
clkin,
startsig,
maxcount
);

input clkin;
input startsig;
input [15:0]maxcount;   

reg state[1:0] = 0;
reg laststartsig = 0; 
reg[15:0]count = 0;
always@(posedge clkin)
  begin          
    laststartsig <= startsig;  
    case(state)
      0:
        begin 
          count <= 0;
          if ((startsig == 0) && (laststartsig == 1))
            begin
              count <= count + 1;
              state <= 1;
            end
        end
      1:
        begin  
          count <= count + 1;
          if(count >= maxcount)
            state <= 2;
        end         
      2:
        begin  
          if ((startsig == 0) && (laststartsig == 1))
            begin
              state <= 0;
            end
        end
    endcase
  end

[Frank S. (schroederde)]

Hmm. Funzt [verilog]?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Frank S. schrieb:
> Hmm. Funzt [verilog]?
Nein. Nimm [c] oder [code]

[T. F. (sar)]

Hi,

Vielen Dank für die Kommentare. Teile des Codes stammen aus dem Projekt, 
welches ich mit dieser Triggerung / Synchronisierung erweitern will. 
Habe von dort die # Geschichten übernommen.

Danke Frank für deinen Code. Habe jetzt in der Zwischenzeit Xilinx ISE 
wieder hochgefahren und verwende dieses zum Simulieren. Damit habe ich 
schon gearbeitet.

@Frank: Wieso bist du den Weg über eine State-Maschine gegangen?

Folgendes erzeugt unter Xilinx ISE das gewünschte Verhalten:

`timescale 1ns / 1ns

module test(
    input clk,
    input sync,
    input rst
    );


reg      reset_sw_n;
reg      sync_r;
reg [12:0]  cnt;
reg       enable;


always @(posedge clk)
begin
  reset_sw_n <= ~rst;
end


always @(posedge clk) begin
  sync_r <= sync;
  
  if (reset_sw_n) begin
    cnt <= 13'b0 ;
    enable <= 0;
  end else if ((sync_r == 1) && (sync == 0) && (enable== 0)) begin
    enable <= 1;
  end else if (enable) begin
    if (cnt == 13'd16) begin
      cnt <= 0;
      enable <= 0;
    end else begin
      cnt <= cnt + 1;
    end
    
  end
end

endmodule

Werde das jetzt mal auf der Hardware ausprobieren.

Danke an alle

[Vancouver (Gast)]

Wo genau das Problem liegt, sehe ich Moment auch nicht (Ich bin 
System-Verilog Novize), aber einen Fehler sehe ich: Du testest auf 
sync_in_r1==0 und sync_in_r==1, damit hast Du aber eine steigende und 
keine fallende Flanke (weil sync_in_r1 der ältere Wert ist).

Weiterhin könntest Du

  else if(sync_in_r1 == 1'b0)
    if (sync_in_r == 1'b1)

vereinfachen zu

  else if(sync_in_r1 == 1'b0 && sync_in_r == 1'b1)

und die ersten beiden always-statements mergen. Das alles löst nicht das 
Problem, aber der Code wird übersichtlicher, vllt findest Du dann 
heraus, was schiefläuft. Hat cnt die gleiche Breite wie StopValue? 
Verilog macht da manchmal seltsame Sachen ohne Vorwarnung. Ja, und lass 
die Timing-Statements erst mal raus. Es geht jetzt nur um die funtionale 
Simulation

[T. F. (sar)]

Hi,

Mit obigem Code funktionierts jetzt.

Danke nochmals.

[Frank S. (schroederde)]

Hi

T. F. schrieb:
> @Frank: Wieso bist du den Weg über eine State-Maschine gegangen?

Weil Deine Aufgabenbeschreibung nach einer State-Machine geschriehen hat 
;)

T. F. schrieb:
> Ich habe einen Eingang, sync_in, und wenn dieser von high auf low
> wechselt, möchte ich einen Zähler starten.

entpricht:

        //state 0
        if ((startsig == 0) && (laststartsig == 1))
            begin
              count <= count + 1;
              state <= 1;
            end

T. F. schrieb:
> Der Zähler soll dann weiter
> inkrementieren bis er einen maximalen Wert erreicht.

         //state 1
         if(count >= maxcount)
            state <= 2;

T. F. schrieb:
> Dann soll der
> Zähler auf 0 zurück gesetzt werden und bis auf die nächste fallende
> Flanke warten.

Oh hier war ein Fehler:

          // state 2
          count <= 0; //Hatte ich vergessen
          if ((startsig == 0) && (laststartsig == 1))
            begin
              state <= 0; //Wenn er sofort wieder zu zählen beginnen soll
                          //state <= 1;
            end

...Ausserdem finde ich eine Statemachine deutlich übersichtlicher als 
die ganzen verschachtelten ifs.

[Lattice User (Gast)]

T. F. schrieb:
>
> Mit obigem Code funktionierts jetzt.
>

Allerdings fehlt diesem das korrekte Einsynchroniseren des externen 
Syncsignals. In der orginalen Version war das noch vorhanden. Ohne wird 
es ab und zu auf der Hardware Fehler geben. Die Statemachine Version von 
Frank kann sogar in einen illegalen Zustand springen.

[Frank S. (schroederde)]

Naja, wenn schon Erbsen zählen, dann aber richtig.

Lattice User schrieb:
> Die Statemachine Version von
> Frank kann sogar in einen illegalen Zustand springen.

Was aber völlig gleichgültig ist. Das Modul hat keine Ausgänge.

Dieses Snippet sollte keine vollständige Lösung darstellen, sondern 
einen Weg aufzeigen.

[T. F. (sar)]

@Lattice User:

Ja das war in dieser Version noch nicht drinnen, habe ich dann aber nach 
den ersten Tests wieder eingebaut.