Xilinx ISE - VHDL: plantilla de código para crear una ROM

Sería mejor utilizar un enfoque VHDL puro de proveedor independiente (y, por lo tanto, portátil). Cualquier buena herramienta de síntesis deducirá una ROM de este código:

case address is
    when 1 =>      result <= 14;
    when 2 =>      result <= 45;
    when 3 =>      result <= 67;
    when 4 =>      result <= 32;
    when 5 =>      result <= 12;
    when 6 =>      result <= 64;
    ...
    when others => result <= 0;  -- Default
end case;

Esto no está en VHDL, pero proporciona una respuesta al problema general que otros pueden encontrar útil.

Puede usar un núcleo IP de Generador de Memoria de Bloque para hacer lo que quiera. Esto se crea agregando un archivo fuente de tipo coregen a su proyecto y seleccionando Generador de memoria de bloques de la lista de núcleos disponibles. Puede personalizar el tipo de memoria, le gustaría elegir ROM en este caso, por supuesto, el tamaño y también proporcionar un archivo de inicialización de memoria. Este archivo .coe se describe en enlace

Querrías algo como esto:

Memory_Initialization_Radix=16;
Memory_Initialization_Vector=
0E,2D,43,20,0C,40,59,22,36,16;

Aquí hay un ejemplo de VHDL de hacerlo en el código fuente: algunos datos se omiten para mayor claridad:

 entity cgrom is
 port (clkin : in std_logic;
      adr : in std_logic_vector(13 downto 0);
     data:out std_logic_vector(3 downto 0));
     end cgrom; 

 architecture a_cgrom of cgrom is

 attribute INIT_00 :string;attribute INIT_01 :string;attribute INIT_02 :string;attribute INIT_03 :string; 
attribute INIT_04 :string;attribute INIT_05 :string;attribute INIT_06 :string;attribute INIT_07 :string;

attribute INIT_00 of chargen0: label is "0000000000000000000000000000000000000000000000000000000000000000";
attribute INIT_01 of chargen0: label is "00000000000000E000E00060000000200040006000E000E000E000E000E00000";
attribute INIT_02 of chargen0: label is "00000000000000000000000000000000000000000000011C011C011C011C0000";
attribute INIT_03 of chargen0: label is "0000000000000048007C005C00CC01D800B800B801B007FC0330017007700260";
attribute INIT_04 of chargen0: label is "00000020002000DC03FC01080120035000F0005C0028030C01FC035800200000";
attribute INIT_05 of chargen0: label is "00000000000001800600006002C0039C0384038C0398006A0076003600300000";
attribute INIT_06 of chargen0: label is "00000000002002F803BA059E03CC03E60654007800700030001C00F800F80020";
attribute INIT_07 of chargen0: label is "0000000000000000000000000000000000000000000000600060006000600000";

Convertiré tu código de ejemplo en algo que infiere una ROM:

En algún lugar de su sección de arquitectura, cree las señales para acceder a su ROM (la inferencia de ROM requiere un resultado cronometrado) para simplificar (evitando la verbosidad del tipo de VHDL que contiene el ejemplo) He convertido sus números a hexadecimal:

subtype nybble is std_logic_vector(3 downto 0);
subtype byte is std_logic_vector(7 downto 0);

signal romClock   : std_logic;
signal romAddress : nybble;
signal romResult  : byte;

Luego, en la sección de comportamiento, un proceso como el siguiente infiere una ROM:

myROM: process(romClock,romAddress) is
begin
    if (rising_edge(romClock)) then
        case romAddress is
            when x"1"   => romResult <= x"0E"; -- 14
            when x"2"   => romResult <= x"2D"; -- 45
            when x"3"   => romResult <= x"43"; -- 67
            when x"4"   => romResult <= x"20"; -- 32
            when x"5"   => romResult <= x"0C"; -- 12
            when x"6"   => romResult <= x"40"; -- 64
            when others => romResult <= x"00"; -- 0
        end case;
    end if;
end process myROM;

He tenido que hacer esto varias veces en mi diseño Commodore-64-on-Zybo mediante scripts de Python para convertir los datos binarios de ROM (Character, Basic y Kernal ROM) en fuentes VHDL que contienen la enorme línea 4K / 8K los bloques de casos dentro de ellos (si necesito escribir un convertidor, de todos modos también puedo convertir a VHDL genérico en lugar de los archivos de descripción de contenido de memoria textual específicos del proveedor).

Con solo el bloque CASE, se obtiene un selector de constante combinacional implementado en LUT en lugar de una ROM. Para deducir una ROM, la asignación de la señal de resultado debe realizarse en un borde del reloj.

Repita este patrón para generar ROM adicionales.

One gotcha: no puede generar más de una salida por reloj por ROM (esto evitará la inferencia de una ROM si ocurre en su diseño). Para salidas múltiples, debe dividir los datos en ROM separadas para cada salida (solución de intercalación) o usar un FSM cíclico pequeño con dos estados por resultado requerido y cronometrar este FSM en los bordes ambos de su reloj de entrada ( solución deserializante). Genere la dirección de la ROM en los estados del borde (suponiendo que las salidas de la ROM estén en los bordes + como en el ejemplo anterior) y asigne la señal de la salida de la ROM en los estados del borde +. Asegúrese de que cualquier estado de sincronización o reinicio asíncrono y los estados inicializados / iniciales sean uno de los estados de borde.