Affectation d'une valeur à un bit spécifique dans un tableau 2D non compressé [system-verilog]

Question

J'essaie d'attribuer une valeur à un bit spécifique d'un tableau 2D (code [i] [k]). C'est un type net. Mais la valeur n'étant pas assignée.reg [3: 0] code [0: 3] obtient la valeur logique inconnue 'X'.

Voici le code snippet

  for(k=0;k<len;k++) begin 
       if (tc[k] == 1'b0) begin 
        code[i][k]= 1'b0;//----> value is not assigning as expected 
       end else begin 
        code[i][k]= 1'b1;// ---> value is not assigning as expected 
       end 
      end 
      codeLen[i] = len; 

Cette boucle appartient à toujours block.Here, Code et codeLen est le type de sortie.

output [3:0] code[0:3]; 
output [3:0] codeLen[0:3]; 
reg [3:0] code[0:3]; 
reg [3:0] codeLen[0:3]; 

codeLen [i] est correctement affectée, mais pas le code [i] [k]. J'essayais d'assigner le k-ème bit du i-ème octet.

Détails J'ai créé un module qui prend 6 entrées et renvoie deux tableaux bidimensionnels en sortie.

Voici le module:

`timescale 1ns/1ps 
module generate_code(CLK,nRST,nodes,nodeCount,characters,charCount,code,codeLen); 
input CLK; 
input nRST; 
input integer nodeCount;//Total nodes in huffman tree 
input integer charCount;//Total unique characters 
input [6:0] characters[0:3]; 
input [23:0] nodes[0:6]; // total characters 

output [3:0] code[0:3]; //[2:0] max code length <= total characters 
output [3:0] codeLen[0:3]; 

reg [3:0] code[0:3]; 
reg [3:0] codeLen[0:3]; 

reg[3:0] tc;//temprary code reg. Holds a single bit in each byte 
integer len=0;//code length 
reg [23:0] tNode; 

function void FindRoot; 
    reg [23:0] aNode;//local 
    integer i; 
    begin 
    for (i=0; i<nodeCount;i++) begin // For all nodes 
     aNode= nodes[i]; // aNode is current node 
     if (tNode[23:16] == aNode[14:7]) begin 
      tc[len]= tNode[15];//15th bit of nodes is codebit 
      len++; 
     //aNode is parent of tNode. Is it root? 
      if(aNode[23:16]==8'b0000_0000) begin//or frequency==nodeCount or node_id = 8'b1111_1111 
       return; 
      end else begin 
       tNode=aNode; 
       FindRoot(); 
      end 
     end 
    end 
    end 
endfunction 

always@(posedge CLK or negedge nRST) 
begin 
    if(!nRST) begin 
    // init 
    end 
    else begin 
     // Do code generation 
     integer i,j,k; 
     for(i= 0;i < charCount;i++) begin // For all character we are going to find codeword 
      for(j=0; j<nodeCount; j++) begin 
       tNode= nodes[j];//current node 
       if (characters[i] == tNode[6:0]) begin 
       // Got the character. tNode is a leaf nodes. Lets back track to root. 
        break; 
       end 
      end 
      len=0; 
      FindRoot(); 
      for(k=0;k<len;k++) begin 
       if (tc[k] == 1'b0) begin 
        code[i][k]= 1'b0; 
       end else begin 
        code[i][k]= 1'b1; 
       end 
      end 
      //code[i]=2; 
      codeLen[i]= len; 
     end 
    end 
end 
endmodule 

Quand je suis attribuer des valeurs au code [] [], il est prévu que la boucle suivante est exécutée. Bien que tous les bits de code [] [] ne seront pas définis. Pendant le débogage, quand je suis arrivé à l'assignation, j'ai trouvé que la valeur n'était pas assignée (code [i] [k] = 1 ou 0). Sa valeur logique obtenir inconnue X.

   for(k=0;k<len;k++) begin 
       if (tc[k] == 1'b0) begin 
        code[i][k]= 1'b0; 
       end else begin 
        code[i][k]= 1'b1; 
       end 
      end 

Testbench:

`timescale 1ns/1ps 
module generate_code_test; 

// Inputs 
reg CLK; 
reg nRST; 
integer nodeCount=7;//Total nodes in huffman tree 
integer charCount=4;//Total unique characters 
reg [6:0] characters[0:3]; 
reg [23:0] nodes[0:6]; // total characters 

// Outputs 
wire [3:0] code[0:3]; //[2:0] max code length <= total characters 
wire [3:0] codeLen[0:3]; 

generate_code uut (
    .CLK(CLK), 
    .nRST(nRST), 
    .nodes(nodes), 
    .nodeCount(nodeCount), 
    .characters(characters), 
    .charCount(charCount), 
    .code(code), 
    .codeLen(codeLen) 
); 

initial begin 
    // Initialize Inputs 
    CLK = 0; 
    nRST = 0; 
    nodeCount= 7; 
    charCount= 4; 
    characters[0]= 7'b110_0001; 
    characters[1]= 7'b110_0010; 
    characters[2]= 7'b110_0011; 
    characters[3]= 7'b110_0100; 

    nodes[0] = 24'b0000_0011_0_0000_0001_110_0001; 
    nodes[1] = 24'b0000_0011_1_0000_0010_110_0011; 
    nodes[2] = 24'b0000_0101_1_0000_0011_111_1111; 
    nodes[3] = 24'b0000_0101_0_0000_0100_110_0010; 
    nodes[4] = 24'b1111_1111_1_0000_0101_111_1111; 
    nodes[5] = 24'b1111_1111_0_0000_0110_110_0100; 
    nodes[6] = 24'b0000_0000_0_1111_1111_111_1111; 

    // Wait 10 ns for global reset to finish 
    #10; 
    nRST = 1; 

end 
parameter DELAY = 1; 
always 
    #DELAY CLK = ~CLK; 

endmodule 

Le code a été compilé en 2016 ModelSim Je viens de commencer l'apprentissage Verilog. Donc j'apprécierais vraiment votre aide pour montrer mes erreurs. Cordialement.

Answer 1

J'ai obtenu une solution à mon problème. Tous les bits de code [] [] n'ont pas été définis. Cela conduit à une valeur de logique inconnue dans le code [] [] même après le réglage du bit. Il est résolu après l'initialisation de tous les bits de code [] [] dans toujours.