Baies et mémoires Verilog

Un tableau la déclaration d'un réseau ou d'une variable peut être scalaire ou vectorielle. N'importe quel nombre de dimensions peut être créé en spécifiant une plage d'adresses après le nom de l'identifiant et s'appelle un tableau multidimensionnel. Les tableaux sont autorisés dans Verilog pour reg , wire , integer et real Types de données.

  
  
	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

  

Un index pour chaque dimension doit être spécifié pour accéder à un élément particulier d'un tableau et peut être une expression d'autres variables. Un tableau peut être formé pour l'un des différents types de données pris en charge dans Verilog.

Notez qu'une mémoire de n reg de 1 bit n'est pas la même chose qu'un reg de vecteur de n bits.

Devoir

  
  
	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

  

Exemple

Le code ci-dessous montre simplement comment différents tableaux peuvent être modélisés, attribués et accessibles. mem1 est un vecteur 8 bits, mem2 est un tableau 8 bits avec une profondeur de 4 (spécifié par la plage [0:3]) et mem3 est un tableau 2D vectoriel 16 bits avec 4 lignes et 2 colonnes. Ces variables reçoivent des valeurs différentes et sont imprimées.

  
  
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

  

Journal de simulation

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.

Souvenirs

Les mémoires sont des éléments de stockage numérique qui permettent de stocker des données et des informations dans des circuits numériques. Les RAM et les ROM sont de bons exemples de tels éléments de mémoire. Les éléments de stockage peuvent être modélisés à l'aide de tableaux unidimensionnels de type reg et s'appelle une mémoire . Chaque élément de la mémoire peut représenter un mot et est référencé à l'aide d'un seul index de tableau.

Enregistrer le vecteur

Les vecteurs Verilog sont déclarés à l'aide d'une plage de tailles sur le côté gauche du nom de la variable et ceux-ci sont réalisés en flops qui correspondent à la taille de la variable. Dans le code ci-dessous, le module de conception accepte l'horloge, la réinitialisation et certains signaux de contrôle pour lire et écrire dans le bloc.

Il contient un élément de stockage 16 bits appelé registre qui est simplement mis à jour lors des écritures et renvoie la valeur actuelle lors des lectures. Le registre est écrit lorsque sel et wr sont au niveau haut sur le même front d'horloge. Il renvoie les données actuelles lorsque sel est haut et wr est bas.

  
  
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

  

Le schéma matériel montre qu'un flop 16 bits est mis à jour lorsque la logique de contrôle pour les écritures est active et que la valeur actuelle est renvoyée lorsque la logique de contrôle est configurée pour les lectures.

Tableau

Dans cet exemple, le registre est un tableau qui comporte quatre emplacements, chacun ayant une largeur de 16 bits. Le module de conception accepte un signal d'entrée supplémentaire appelé addr pour accéder à un index particulier dans le tableau.

  
  
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

  

On peut voir dans le schéma matériel que chaque index du tableau est un flop 16 bits et que l'adresse d'entrée est utilisée pour accéder à un ensemble particulier de flops.