Verilog Arrays e Memórias

Uma matriz declaração de uma rede ou variável pode ser escalar ou vetorial. Qualquer número de dimensões pode ser criado especificando um intervalo de endereços após o nome do identificador e é chamado de matriz multidimensional. Arrays são permitidos em Verilog para reg , wire , integer e real tipos de dados.

  
  
	reg        y1 [11:0];        // y is an scalar reg array of depth=12, each 1-bit wide
	wire [0:7] y2 [3:0]          // y is an 8-bit vector net with a depth of 4
	reg  [7:0] y3 [0:1][0:3];    // y is a 2D array rows=2,cols=4 each 8-bit wide

  

Um índice para cada dimensão deve ser especificado para acessar um determinado elemento de uma matriz e pode ser uma expressão de outras variáveis. Uma matriz pode ser formada para qualquer um dos diferentes tipos de dados suportados no Verilog.

Observe que uma memória de n reg de 1 bit não é o mesmo que um reg de vetor de n bits.

Tarefa

  
  
	y1 = 0; 						// Illegal - All elements can't be assigned in a single go
	
	y2[0] = 8'ha2; 			// Assign 0xa2 to index=0 
	y2[2] = 8'h1c; 			// Assign 0x1c to index=2
	y3[1][2] = 8'hdd; 	// Assign 0xdd to rows=1 cols=2
	y3[0][0] = 8'haa; 	// Assign 0xaa to rows=0 cols=0

  

Exemplo

O código mostrado abaixo simplesmente mostra como diferentes arrays podem ser modelados, atribuídos e acessados. mem1 é um vetor de 8 bits, mem2 é um array de 8 bits com profundidade de 4 (especificado pelo intervalo [0:3]) e mem3 é um array 2D de vetor de 16 bits com 4 linhas e 2 colunas. Essas variáveis ​​recebem valores diferentes e são impressas.

  
  
module des ();
  reg [7:0]  mem1; 							// reg vector 8-bit wide
  reg [7:0]  mem2 [0:3]; 				// 8-bit wide vector array with depth=4
  reg [15:0] mem3 [0:3][0:1]; 	// 16-bit wide vector 2D array with rows=4,cols=2
  
  initial begin
    int i;
    
    mem1 = 8'ha9;
    $display ("mem1 = 0x%0h", mem1);
    
    mem2[0] = 8'haa;
    mem2[1] = 8'hbb;
    mem2[2] = 8'hcc;
    mem2[3] = 8'hdd;
    for(i = 0; i < 4; i = i+1) begin
      $display("mem2[%0d] = 0x%0h", i, mem2[i]);
    end
    
    for(int i = 0; i < 4; i += 1) begin
      for(int j = 0; j < 2; j += 1) begin
        mem3[i][j] = i + j;
        $display("mem3[%0d][%0d] = 0x%0h", i, j, mem3[i][j]);
      end
    end
  end
endmodule

  

Registro de simulação

ncsim> run
mem1 = 0xa9
mem2[0] = 0xaa
mem2[1] = 0xbb
mem2[2] = 0xcc
mem2[3] = 0xdd
mem3[0][0] = 0x0
mem3[0][1] = 0x1
mem3[1][0] = 0x1
mem3[1][1] = 0x2
mem3[2][0] = 0x2
mem3[2][1] = 0x3
mem3[3][0] = 0x3
mem3[3][1] = 0x4
ncsim: *W,RNQUIE: Simulation is complete.

Memórias

As memórias são elementos de armazenamento digital que ajudam a armazenar dados e informações em circuitos digitais. RAMs e ROMs são bons exemplos de tais elementos de memória. Elementos de armazenamento podem ser modelados usando arrays unidimensionais do tipo reg e é chamado de memória . Cada elemento na memória pode representar uma palavra e é referenciado usando um único índice de matriz.

Registrar Vetor

Os vetores Verilog são declarados usando um intervalo de tamanho no lado esquerdo do nome da variável e são realizados em flops que correspondem ao tamanho da variável. No código mostrado abaixo, o módulo de projeto aceita clock, reset e alguns sinais de controle para ler e escrever no bloco.

Ele contém um elemento de armazenamento de 16 bits chamado registrador que simplesmente é atualizado durante as gravações e retorna o valor atual durante as leituras. O registrador é escrito quando sel e wr estão em nível alto na mesma borda de clock. Ele retorna os dados atuais quando sel é alto e wr é baixo.

  
  
module des (    input           clk,
                input           rstn,
                input           wr,
                input           sel,
                input [15:0]    wdata,
                output [15:0]   rdata);

	reg [15:0] register;

	always @ (posedge clk) begin
    if (!rstn)
    	register <= 0;
    else begin
    	if (sel & wr) 
      	register <= wdata;
    	else
      	register <= register;
    end
	end

	assign rdata = (sel & ~wr) ? register : 0;
endmodule

  

O esquema de hardware mostra que um flop de 16 bits é atualizado quando a lógica de controle para gravações está ativa e o valor atual é retornado quando a lógica de controle é configurada para leituras.

Matriz

Neste exemplo, registrador é uma matriz que possui quatro locais, cada um com uma largura de 16 bits. O módulo de design aceita um sinal de entrada adicional chamado addr para acessar um índice específico na matriz.

  
  
module des (    input           clk,
                input           rstn,
                input  [1:0]    addr,
                input           wr,
                input           sel,
                input [15:0]    wdata,
                output [15:0]   rdata);

reg [15:0] register [0:3];
integer i;

always @ (posedge clk) begin
    if (!rstn) begin
        for (i = 0; i < 4; i = i+1) begin 
            register[i] <= 0;
        end
    end else begin
        if (sel & wr) 
            register[addr] <= wdata;
        else
            register[addr] <= register[addr];
    end
end
 
assign rdata = (sel & ~wr) ? register[addr] : 0;
endmodule

  

Pode ser visto no esquema de hardware que cada índice do array é um flop de 16 bits e o endereço de entrada é usado para acessar um determinado conjunto de flops.