Merkwürdige RTL Schematic (Spartan 6)

[Thomas S. (th0ms0n)]

Hiho,

erster Beitrag. Daher fröhliches HALLO an alle Beteiligten.
Seit einigen Wochen beschäftige ich mich mit FPGA Design mit Verilog und 
als ich mir letztens folgende RTL Schematic angesehen habe, war ich 
etwas ratlos.
Was passiert auf dem Bild im Anhang?
In den Output UND Input vom MUX fließt Strom hinein? Und in den Ausgang 
vom FF?? Sehr merkwürdig.

Ich vermute, dass die Verwendung mehrerer nonblocking Assignments im 
selben Always-Block auf die selbe Variable daran Schuld sein könnten.
Laut Standard ist das legitim und das letzte Assignment gewinnt. Aber 
vllt. zerschießt das ja die Synthese?

Danke und beste Grüße,
Thomy

EDIT: hier der Code:
Im Grunde greifen mehrere prime-Module, die per generate erzeugt wurden, 
später im always-Block auf das uart-Modul zu, und ich vermute, dadurch 
entsteht die verrückte Schematic.

`timescale 1ns/1ns


// number of parallel prime solvers
`define CNT 5


// start of counter module
module counter(rawclk,
               key,
               led,
               TMP_SCL,
               TMP_SDA,
               TMP_ALERT,
               RxD,
               TxD);
// ports
input wire TMP_SCL, TMP_SDA, TMP_ALERT, RxD;
input wire rawclk;
input wire [1:0] key;
output wire TxD;
output reg [3:0] led = 4'b0;

// parameters
parameter IDLE  = 2'b00,
          CALC  = 2'b01,
          COUNT = 2'b10;
          
// pll
wire clk;
clock myclk(.CLK_IN1(rawclk),
            .CLK_OUT1(clk));
       
// prime module
reg reset = 1'b0, reset2 = 1'b0;
reg [ 2 * `CNT - 1:0] state;
reg [32 * `CNT - 1:0] counter;
reg [     `CNT - 1:0] runprime;
wire [2 * `CNT - 1:0] isprime;

genvar i;
generate
    for (i = 0; i < `CNT; i = i + 1)
    begin: COUNTERS
        prime pr(.clk(clk),
                 .reset(reset2),
                 .num(counter[i * 32+:32]),
                 .run(runprime[i]), 
                 .isprime(isprime[i * 2+:2]));
    end   
endgenerate

// init prime params
integer k;
initial
begin
    for (k = 0; k < `CNT; k = k + 1)
    begin
        counter[k * 32+:32] = 32'd2 + k;
        runprime[k]         = 1'b0;
        state[2 * k+:2]     = IDLE;
    end
end    

// uart sender
wire sendbusy;
reg  sendrun = 1'b0;
reg [7:0] senddata = 8'b0;
uartsend send(.clk(clk),
              .reset(reset2),
              .data(senddata),
              .run(sendrun),
              .txout(TxD),
              .busy(sendbusy)); 

// always block
always@(posedge clk)
begin 
    reset   <= |key;
    reset2  <= reset;
    sendrun <= 1'b0;

    for (k = 0; k < `CNT; k = k + 1)
    begin  
        if (reset2)
        begin
            counter[k * 32+:32] <= 32'd2 + k;
            runprime[k]         <= 1'b0;
            state[2 * k+:2]     <= IDLE;
            led                 <= 4'b1010;
            sendrun             <= 1'b0;
            senddata            <= 8'b0;
        end
        else
        begin
            runprime[k] <= 1'b0;
                    
            case (state[2 * k+:2])
            IDLE:
            begin
                runprime[k]     <= 1'b1;  
                state[2 * k+:2] <= CALC;               
            end
            CALC:
            begin                
                if (isprime[k * 2+:2] != COUNTERS[0].pr.UNKNOWN)
                begin
                    if (isprime[k * 2+:2] == COUNTERS[0].pr.FOUND)
                    begin
                        $display("found: %d", counter[k * 32+:32]);
                        led <= counter[k * 32 + 1+:4];
                        
                        if (sendbusy == 1'b0)
                        begin
                            senddata <= counter[k * 32+:8];
                            sendrun  <= 1'b1;
                        end
                    end                    
                    state[2 * k+:2] <= COUNT;  
                end                         
            end
            COUNT:
            begin
                counter[k * 32+:32] <= (counter[k * 32+:32] > 32'hFFFFFFFF - `CNT) ? 
                                        32'd2 + k : counter[k * 32+:32] + `CNT;
                state[2 * k+:2] <= IDLE;            
            end
            default:
                state[2 * k+:2] <= IDLE;
            endcase    
        end // for
    end // reset
end // always
    
endmodule

[Der Besucher (Gast)]

Ich denke, du weist in verschiedenen Tasks dem Bus Werte zu. Dann wird 
das auch brav alles angeschlossen und die Ausgänge miteinander 
verknüpft.

Hast du den entsprechenden Codeschnipsel für uns?

Der Besucher

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

Thomas S. schrieb:
> EDIT: hier der Code:
Weil viele behaupten Verilog läse sich wie C könntest du die C-Tags fürs 
Syntax-Highlighting nehmen:

Formatierung 
    [c]C-Code[/c]