Verilog Problem

[hans (Gast)]

              //  Ansprechen des Masterinterfaces

wire [31:0] data [0:4];        // 4 Byte Datenfeld
wire control_fixed_location;
wire [31:0] control_write_base;
wire [31:0] control_write_length;
wire control_go;
wire data_to_buffer;
wire control_done;
wire [1:0]  button_pio_deb;

assign control_fixed_location = 1'b0;
assign control_write_base = 32'h08FFFFAA;
assign control_write_length = 32'h00000004;

reg control_go_reg =1'b0;
reg data_to_buffer_reg=1'b0;
reg led_pio_reg_1=1'b1;
reg led_pio_reg_2=1'b1;
reg button_old_1=1'b1;
reg button_new_1=1'b1;
reg button_old_2=1'b1;
reg button_new_2=1'b1;

Debounce Debounce_1(
      .clk(clkin_100),
    .keyin(button_pio[0]),
    .keyout(button_pio_deb[0])  

);

Debounce Debounce_2(
      .clk(clkin_100),
    .keyin(button_pio[1]),
    .keyout(button_pio_deb[1])  
);


always @(posedge clkin_100)
begin
       button_old_1 = button_new_1;
      button_new_1 = button_pio_deb[0];
 
    if ( button_new_1==1'b0 && button_old_1==1'b1)  begin
         control_go_reg = 1'b1 ;   
         led_pio_reg_1 = 1'b0;
        led_pio_reg_2 = 1'b1;
        
   end
   else  begin
        control_go_reg= 1'b0; 
   end
   
    button_old_2 = button_new_2;
     button_new_2 = button_pio_deb[1];
 
    if ( button_new_2==1'b0 && button_old_2==1'b1)  begin
         data_to_buffer_reg = 1'b1 ;   
         led_pio_reg_2 = 1'b0;
       led_pio_reg_1= 1'b1;
   end
   else  begin
        data_to_buffer_reg = 1'b0; 
   end
 
    
end




assign data_to_buffer = data_to_buffer_reg;
assign control_go = control_go_reg;

assign data[0] = 32'hAABBAAFF;
assign data[1] = 32'hAABBAAFE;
assign data[2] = 32'hAABBAAFD;
assign data[3] = 32'hAABBAAFC;

assign led_pio[0] = control_done;
assign led_pio[1] = led_pio_reg_1;
assign led_pio[2] = led_pio_reg_2;
assign led_pio[3] = 1;

[hans (Gast)]

Hallo helfer,


ich habe ein Problem mit meinem verilog code. ich möchte ein 
Masterinterface ansteuern und dazu sollen 2 Signale jeweils mit einem 
Taster geschalten werden. Ich benutze eine Entprellung in VHDL von 
lothar Miller. Nun mein problem ist das die Abfrage   if ( 
button_new_1==1'b0 && button_old_1==1'b1) nicht erreicht wird.

In der Simulation klappt es und es klappt auch wenn ich statt dem 
debounce Signal (button_pio_deb[0]) das nicht Entprellte benutze.

habe ich irgendwelche Timingprobleme mit dem Debounce Block oder woran 
könnte es scheitern das bei Verwendung des Debounce Signals die LEDs 
nicht geschalten werden aber bei verwendung des prellenden Signals 
schon.


Grüße

[auch Hans (Gast)]

Hi!
Unabhängig von deinem Problem empfehle ich dir

   button_old_1 <= button_new_1;
   button_new_1 <= button_pio_deb[0];

statt

   button_old_1 = button_new_1;
   button_new_1 = button_pio_deb[0];

zu verwenden (eigentlich überall das = durch <= ersetzen; jedenfalls 
innerhalb des always-Blocks).

Und dann google am Besten mal nach dem Unterschied zwischen blocking und 
non-blocking assignments in Verilog und vergiss Zuweisungen mit = in 
einem Block ganz schnell wieder. Sonst wird das hier nicht das letzte 
Problem sein, daß du lösen musst.

Ansonsten poste doch mal den VHDL Code vom Debouncer. Kennt ja nicht 
jeder hier Lothars Code auswendig (schon garnicht wenn es VHDL ist).

Grüße,
Hans

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

auch Hans schrieb:
> Ansonsten poste doch mal den VHDL Code vom Debouncer.
Der muss irgendwo dort sein:
http://www.lothar-miller.de/s9y/categories/5-Entprellung
> Kennt ja nicht jeder hier Lothars Code auswendig
;-)

[auch Hans (Gast)]

Wird wohl der hier sein.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.numeric_std.ALL;

entity Debounce is
    Port ( clk    : in  STD_LOGIC;
           keyin  : in  STD_LOGIC;
           keyout : out  STD_LOGIC);
end Debounce;

architecture Behavioral of Debounce is
signal keydeb : std_logic := '0';
signal debcnt : integer range 0 to 63 := 0;
begin
   process begin
      wait until rising_edge(clk);
      -- XOR
      if (keyin=keydeb) then debcnt <= 0;
      else                   debcnt <= debcnt+1;
      end if;
      -- Latch
      if (debcnt=63) then keydeb <= keyin; 
      end if;
   end process;
   keyout <= keydeb;

end Behavioral;

Schließ die LEDs doch für nen Test mal direkt an button_pio_deb an. Dann 
siehst du immerhin ob der Ausgang vom Debouncer funktioniert, wenn du 
denn Taster drückst.

[hans (Gast)]

hey das problem mit dem schreiben hab ich gelöst hab was im debounce 
ungünstig verändert^^.


habe aber nun eien allg. verilog frage.


ich hab ein reg data_read_reg = 32'h00000000;


und möchte das mit einem wire zuordnen

assign data[0] = data_read_reg; und das wire ist so

wire [31:0] data [0:4];  deklariert


ist das zulässig? Immer wenn ich dieses 4 byte dann senden möchte gibt 
er mit etwas falsches aus aber wenn ich es direkt über den assign befehl 
mache  assign data[0]=32'h0000000 dann geht es.

[Lattice User (Gast)]

hans schrieb:
> ich hab ein reg data_read_reg = 32'h00000000;

data_read_reg muss so declariert werden:

reg [31:0] data_read_reg;

[hans (Gast)]

achso udn sonst gilt es quasi als 1 Bit reg ?

[auch Hans (Gast)]

Genau. Und bei der zuweisung von data_read_reg an data würden die Bits 
31 bis 1 mit Nullen aufgefüllt werden.
Für alle Signale die mehr als ein Bit enthalten musst du die Größe bei 
der Deklaration explizit angeben. Sonst wird immer 1 Bit angenommen.
Das einzige, wo Verilog Signalgrößen automatisch anpasst ist bei einem 
"implicit wire". Das aber auch nur in den neueren Verilog Standards. Und 
außerdem sollte man sowas nie verwenden.

[Lattice User (Gast)]

auch Hans schrieb:
> Das einzige, wo Verilog Signalgrößen automatisch anpasst ist bei einem
> "implicit wire". Das aber auch nur in den neueren Verilog Standards. Und
> außerdem sollte man sowas nie verwenden.

Kann man mit

`default_nettype none

unterbinden.

[hans (Gast)]

if ( button_new_2==1'b0 && button_old_2==1'b1 && read_data_available==1'b1)  begin
       if((flag==1'b0) & (flag2==1'b0)) begin
         data_read_reg <= data[1];
        read_buffer_done_reg <= 1'b1 ; 
       flag<=1'b1;
       led_pio_reg_1<= 1'b1;
      end
      else if ((flag==1'b1) & (flag2==1'b0)) begin  
      data_read_reg_2 <= data[1];
      read_buffer_done_reg <= 1'b1 ;
        
        
       led_pio_reg_1<= 1'b0;
       read_or_write<=1'b1;
       flag2<=1'b1;
       end
       
   end

ich habe mal eine Frage zu diesen Codestück. Ich werte eine fallende 
Flanke eines Buttons aus der entprellt ist. Beim ersten drücken soll 
etwas ausgeführt werden und beim 2. etwas anderes das habe ich durch die 
flags versucht umzusetzen. Nun passiert es aber das manchmal nur das 
erste ausgeführt wird und manchmal beides . Ich weiss nicht woran es 
liegen kann ich habe auch schon versucht die entprellzeit zu verlängern 
das hat aber nichts gebracht. liegt es vielleicht an meiner zuweisung 
der flag werte? Eigentlich werden diese doch erst nach dem zeitschritt 
durch <= übernommen oder versteh ich das falsch.


Danke hans

[hans (Gast)]

kann e sein das 63 bzw 127 zu wenig im entprell count sind?

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

hans schrieb:
> kann e sein das 63 bzw 127 zu wenig im entprell count sind?
Das kommt auf den Takt an. Wenn du da mit 50MHz reindonnerst, dann sind 
127 (=20ns*127 = 2,56us) viel zu wenig. Denn so ein Taster/Schalter 
kann schon mal 50ms lang prellen. Und das ist 20000 mal länger als deine 
Entprellzeit...