Capítulo 27: Memoria ROM genérica

Ejemplos de este capítulo en github

Introducción

Las memorias son elementos muy comunes, que usaremos mucho en nuestros diseños. En vez de estar haciendo memorias con un tamaño determinado, es más versátil crear una memoria genérica cuyos parámetros de longitud de datos y de direcciones se establezcan al instanciarlas.

Crearemos una memoria rom genérica y la utilizaremos en dos ejemplo: uno para reproducir una secuencia de luces en los leds y otro para tocar una melodía: la marcha imperial

Memoria rom paramétrica

La memoria rom genérica la denominaremos genrom

Parámetros

Tiene 3 parámetros que se asignan al instanciarse la rom:

• DW (Data width): Anchura de los datos (en bits)
• AW (Address width): Anchura de las direcciones (en bits)
• ROMFILE: Fichero con el contenido de la rom

Puertos

Los puertos de la rom son los clásicos, pero ahora su tamaño no está especificado:

• Addr: Bus de direcciones
• data: Bus de datos
• clk: Reloj del sistema

genrom.v: Descripción en Verilog

Puesto que los puertos (addr y data) son genéricos, y por tanto se tienen que definir al declarar el módulo, es necesario primero definir los parámetros AW y DW. Luego, en función de ellos se definen los puertos. Esto se codifica en verilog con esta estructura:

module nombre #(definición de parametros) (definicion de puertos);

El código verilog de la memoria rom genérica es:

//-- Fichero: genrom.v
module genrom #(             //-- Parametros
         parameter AW = 5,   //-- Bits de las direcciones (Adress width)
         parameter DW = 4)   //-- Bits de los datos (Data witdh)

       (                              //-- Puertos
         input clk,                   //-- Señal de reloj global
         input wire [AW-1: 0] addr,   //-- Direcciones
         output reg [DW-1: 0] data);  //-- Dato de salida

//-- Parametro: Nombre del fichero con el contenido de la ROM
parameter ROMFILE = "rom1.list";

//-- Calcular el numero de posiciones totales de memoria
localparam NPOS = 2 ** AW;

  //-- Memoria
  reg [DW-1: 0] rom [0: NPOS-1];

  //-- Lectura de la memoria
  always @(posedge clk) begin
    data <= rom[addr];
  end

//-- Cargar en la memoria el fichero ROMFILE
//-- Los valores deben estan dados en hexadecimal
initial begin
  $readmemh(ROMFILE, rom);
end

endmodule

El tercer parámetro, ROMFILE, se define de la manera habitual, usando la palabra clave parameter dentro del módulo. Dentro de #() sólo se definen los parámetros que afectan a los puertos

Instanciando la rom en nuestros diseños

La mejor manera de utilizar la rom genérica en nuestros diseños es volviendo a definir los parámetros AW y DW (aunque se pueden usar otros nombres) usando como valores los que necesitemos en nuestro diseño:

parameter AW = 5;
parameter DW = 5;

Ahora declaramos los cables que van conectados a la rom genérica en función de estos parámetros:

reg [AW-1: 0] addr;  //-- Bus de direcciones
reg [DW-1: 0] data;  //-- Bus de datos

y finalmente instanciamos la rom:

genrom 
  #( .ROMFILE(ROMFILE),  //-- Asignacion de parametros
     .AW(AW),
     .DW(DW))
  ROM (                  //-- coneion de cables
        .clk(clk),
        .addr(addr),
        .data(data)
      );

Ejemplo 1: secuencia en los leds

En este ejemplo reproduciremos una secuencia en los leds, igual que en los ejemplos del capítulo anterior, pero usando una rom genérica

Diagrama de bloques

Utilizaremos 5 leds para la secuencia, por lo que la anchura de los datos será de 5 bits (DW = 5), y una anchura de direcciones también de 5 bits (AW = 5, para tener 32 posiciones). La secuencia es un contador. En cada posición de la memoria se almacena su número de dirección

genromleds.v: Descripción en verilog

La descripción en verilog del ejemplo es:

//-- Fichero: genromleds.v
`default_nettype none

`include "divider.vh"

module genromleds (input wire clk,
                   output wire [4:0] leds);

//- Tiempo de envio
parameter DELAY = `T_500ms;

//-- Fichero con la rom
parameter ROMFILE = "rom1.list";

//-- Numero de bits de la direccione
parameter AW = 5;
parameter DW = 5;

//-- Cable para direccionar la memoria
reg [AW-1: 0] addr;

reg rstn = 0;
wire clk_delay;

//-- Instanciar la memoria rom
genrom 
  #( .ROMFILE(ROMFILE),
     .AW(AW),
     .DW(DW))
  ROM (
        .clk(clk),
        .addr(addr),
        .data(leds)
      );

//-- Contador
always @(negedge clk)
  if (rstn == 0)
    addr <= 0;
  else if (clk_delay)
    addr <= addr + 1;

//---------------------------
//--  Temporizador
//---------------------------
dividerp1 #(.M(DELAY))
  DIV0 ( .clk(clk),
         .clk_out(clk_delay)
       );

//-- Inicializador
always @(negedge clk)
  rstn <= 1;

endmodule

Fichero rom1.list

El fichero que se graba en la rom, con la secuencia de ejemplo (contador) es el siguiente:

//-- Fichero rom1.list
//-- Cada linea se corresponde con una posicion de memoria
//-- Se pueden poner comentarios
//-- ROM1: contiene los numeros del 0 al 31 (en hexadecimal)
0   //-- Posicion 0
1   //-- Posicion 1
2
3
4
5
6
7
8
9
A
B
C
D
E
F 
10
11
12
13
14
15
16
17
18
19
1A
1B
1C
1D
1E
1F

Simulación

El banco de pruebas es el mismo que en el capítulo anterior. Para simular ejecutamos:

$ make sim

y en el gtkwave vemos lo siguiente:

Por los leds aparece la secuencia de cuenta, desde 0 hasta 31 (en hexadecimal)

Síntesis y pruebas

Para sintetizar hay que ejecutar el comando:

$ make sint

Los recursos empleados son:

Recurso	ocupación
PIOs	7 / 96
PLBs	16 / 160
BRAMs	1 / 16

El diseño se carga con:

$ sudo iceprog genromleds.bin

Se podrá ver por los leds la secuencia de cuenta

Ejemplo 2: Tocando la marcha imperial

En el segundo ejemplo tocaremos un fragmento de la marcha imperial de star wars. Esto es un clásico en el grupo de Clone wars, tocándose con los motores paso a paso para comprobar su funcionamiento. Pues bien, una FPGA no la tendrás dominada hasta que no toques con ella la marcha imperial :-)

Diagrama de bloques

El diseño consta de una memoria ROM de 64 posiciones de 16 bits. En cada una de ellas se almacena el valor del divisor para generar una nota musical. Los 5 bits menos significativos de cada valor de la nota se envían a los leds, para ver la actividad

El generador de notas (notegen) es similar al que se hizo en el capítulo 17 pero adaptándolo a las reglas del diseño síncrono y haciendo que módulo del contador se pasa como una entrada más, en vez de ser un valor fijo. Además, se ha modificado para que la señal cuadrada generada tenga siempre un ciclo de trabajo del 50% (y que todas las notas suenen con la misma intensidad)

La duración de cada nota se ha establecido en 200ms. Colocando la misma nota en dos posiciones consecutivas de la memoria rom, su duración será el doble (400ms). De esta forma se controla de forma sencilla la duración de todas las notas y los silencios

Descripción en verilog

Los dos ficheros principales son el notegen.v, que contiene el componente de generación de las notas musicales y romnotes.v que tiene el reproductor completo

notegen.v:

module notegen(input wire clk,          //-- Senal de reloj global
               input wire rstn,         //-- Reset
               input wire [15:0] note,  //-- Divisor
               output reg clk_out);     //-- Señal de salida

wire clk_tmp;

//-- Registro para implementar el contador modulo note
reg [15:0] divcounter = 0;

//-- Contador módulo note
always @(posedge clk)

  //-- Reset
  if (rstn == 0)
    divcounter <= 0;      

  //-- Si la nota es 0 no se incrementa contador
  else if (note == 0)
    divcounter <= 0;

  //-- Si se alcanza el tope, poner a 0
  else if (divcounter == note - 1)
    divcounter <= 0;

  //-- Incrementar contador
  else
    divcounter <= divcounter + 1;

//-- Sacar un pulso de anchura 1 ciclo de reloj si el generador
assign clk_tmp = (divcounter == 0) ? 1 : 0;

//-- Divisor de frecuencia entre 2, para obtener como salida una señal
//-- con un ciclo de trabajo del 50%
always @(posedge clk)
  if (rstn == 0)
    clk_out <= 0;

  else if (note == 0)
    clk_out <= 0;

  else if (clk_tmp == 1)
    clk_out <= ~clk_out;
 
endmodule

romnotes.v

Fichero rom1.list

Simulación

Síntesis y pruebas

Ejercicios

• Completar la marcha imperial, aumentando la memoria y añadiendo el resto de notas

Conclusiones

TODO