Instituto Politécnico Nacional

“Unidad Profesional Interdisciplinaria

en Ingeniería y Tecnologías Avanzadas”

“Arquitectura de Computadoras”
Alumnos:
Zarate Angeles Miguel Angel
Fragoso Torres Jesus Eduardo
Rodriguez Perez Daniel

Profesor:
Sergio Garduza Gonzalez

Actividad 3: MEMORIAS

Grupo: 1TM9

8/11/22

Objetivo
Implementara memorias ROM y SRAM de FPGA utilizando VFDL.

Palabras clave
Bytes
Bits
Dirreciones
Decodificacion
Linea de control
Bloques
Ram
Rom
 Memorias

Introduccion teorica
La memoria es un componente imprescindible de una computadora que mantiene
disponibles las instrucciones para el microprocesador o para que el CPU pueda
ejecutarlas. También la memoria se encarga de almacenar temporalmente el
resultado de los procesos ejecutados. Como el microprocesador no es capaz por sí
solo de albergar la gran cantidad de memoria necesaria para almacenar
instrucciones y datos de programa, pueden emplearse transistores como elementos
de memoria en combinación con el microprocesador. Para proporcionar la memoria
necesaria se emplean otros circuitos integrados llamados chips de memoria de
acceso aleatorio (RAM, siglas en inglés), que contienen grandes cantidades de
transistores.

Existen diversos tipos de memorias:

1. Memorias ROM:

Como su nombre lo indica, una memoria de sólo lectura (ROM) es una unidad de
memoria que sólo ejecuta la operación de lectura; no tiene la posibilidad de
escritura.

1.1.1 PROM
 Las PROM son Programmable ROM. Una PROM es una ROM cuyo
contenido puede ser definido a posteriori de construida, mediante una
actividad de programación que se realiza utilizando un circuito electrónico
especial (un Programador de PROMs)

1.1.2 EPROM

Si bien las PROMs significaron un avance, el hecho de no tener "vuelta

atrás" aún significaba una restricción para el uso intensivo de PROMs en
el almacenamiento de programas. De esa necesidad no del todo
satisfecha surgió la tecnología de las EPROM (Erasable PROM). Una
EPROM es una ROM que puede ser borrada.
2. Memorias Ram:
Como vimos anteriormente lo normal es utilizar conjuntos de bits,
organizados en palabras de n bits. Cuando la memoria es de una sola palabra
recibe el nombre de Registro (también puede recibir el nombre de Latch)
cuando tiene múltiples recibe la denominación genérica de RAM. En general
una memoria RAM es un array de 2 m palabras de n bits, de forma similar a
lo que ya analizamos para las ROMs, salvo que en esta oportunidad se
comportan como un arreglo (array) tal como los conocemos en las materias
de programación (si escribo un valor en una posición y leo esa posición el
valor que leo es el que escribí).

Hay distintos tipos de organizaciones de memorias del tipo RAM. Los

elementos que determinan estas variantes son: - si los datos de entrada (lo
que se va a escribir) y de salida (lo que se lee) comparten los mismos
caminos físicos o están separados. - si tienen mas de una única palabra de
n bits. - si requieren de circuitos de "refresco" (veremos qué significa esto
mas adelante). Cuando se tiene una memoria de una única palabra, con
entradas y salidas diferenciadas se habla de Latch o Registro, cuando se
tienen multiples palabras y no se requiere de circuitos de "refresco", se habla
 en general de SRAM, por Static RAM (otro nombre para la polémica, ¿cómo
algo que puede ser modificado recibe el nombre de "estático"?). Lo normal
son las SRAM que tienen la entrada y salida coincidentes en las conexiones,
mientras que las de múltiples palabras con entradas y salidas diferenciadas,
si bien existen, están reservadas a aplicaciones específicas (ej: memorias
para tarjetas de video). Finalmente las memorias de múltiples palabras que
necesitan circuito de refresco, reciben el nombre de DRAM por Dynamic RAM
(no existen memorias tipo Registro que sean a su vez Dinámicas).

Desarrollo
Identifique y describa los tipos de memorias y sus capacidades en los
FPGA de la familia ARTIX-7.

Contiene dos circuitos integrados de memoria: una es una memoria cellular RAM
de 128Mbits (DRAM pseudo-statica) y la otra es una memoria no volátil serial
FLASH. La memoria RAM tiene una interfaz SRAM y la memoria FLASH esta sobre
un bus SPI en modo QUAD (x4) de 32Mb (4MB) que está conectada al FPGA. Las
conexiones y asignaciones de pines entre el FPGA y la memoria FLASH se
muestran en la figura. Es en esta misma memoria donde se guardan los archivos
de configuración.
La memoria RAM tiene un bus de 16 bits que es compatible con un bus de 8 bits.
Puede funcionar como una SRAM asincrónica con ciclos de lecturas y escritura de
70ns, o como una memoria sincrónica de 104MHz. Cuando se utiliza la memoria
RAM en modo asincrónico la RAM actualiza automáticamente sus arreglos internos
DRAM, lo que permite la utilización de un controlador de memoria más simplificado.

Implemetancion de una memoria ROM

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity rom3214 is

Port (

addr: in STD_LOGIC_VECTOR (4 downto 0);--Direccion

M: out STD_LOGIC_VECTOR (13 downto 0)--salida

 );

end rom3214;

architecture arq of rom3214 is—Constantes guardadas en vectores logicos de

dimensión 14

constant data0: STD_LOGIC_VECTOR (13 downto 0) := "01111100000001";

constant data1: STD_LOGIC_VECTOR (13 downto 0) := "11001000000000";

constant data2: STD_LOGIC_VECTOR (13 downto 0) := "00000000000000";

constant data3: STD_LOGIC_VECTOR (13 downto 0) := "00000000000000";

constant data4: STD_LOGIC_VECTOR (13 downto 0) := "00000000000000";

constant data5: STD_LOGIC_VECTOR (13 downto 0) := "00000000000000";

constant data6: STD_LOGIC_VECTOR (13 downto 0) := "01101100000000";

constant data7: STD_LOGIC_VECTOR (13 downto 0) := "11010100000000";

constant data8: STD_LOGIC_VECTOR (13 downto 0) := "10101010000000";

constant data9: STD_LOGIC_VECTOR (13 downto 0) := "00000001010101";

constant data10: STD_LOGIC_VECTOR (13 downto 0) := "00011100111000";

constant data11: STD_LOGIC_VECTOR (13 downto 0) := "00001111000000";

constant data12: STD_LOGIC_VECTOR (13 downto 0) := "00011000000000";

constant data13: STD_LOGIC_VECTOR (13 downto 0) := "00000000011100";

constant data14: STD_LOGIC_VECTOR (13 downto 0) := "01000010000000";

constant data15: STD_LOGIC_VECTOR (13 downto 0) := "00000001001101";

constant data16: STD_LOGIC_VECTOR (13 downto 0) := "00000000000000";

constant data17: STD_LOGIC_VECTOR (13 downto 0) := "00000000000000";

constant data18: STD_LOGIC_VECTOR (13 downto 0) := "00000000000000";

constant data19: STD_LOGIC_VECTOR (13 downto 0) := "00000000000000";

constant data20: STD_LOGIC_VECTOR (13 downto 0) := "00000000000000";

constant data21: STD_LOGIC_VECTOR (13 downto 0) := "00000000000000";

constant data22: STD_LOGIC_VECTOR (13 downto 0) := "11111111000000";

constant data23: STD_LOGIC_VECTOR (13 downto 0) := "00010101000000";

constant data24: STD_LOGIC_VECTOR (13 downto 0) := "00000001100000";

constant data25: STD_LOGIC_VECTOR (13 downto 0) := "11000000000000";

constant data26: STD_LOGIC_VECTOR (13 downto 0) := "00000011010100";

constant data27: STD_LOGIC_VECTOR (13 downto 0) := "00000000011011";

constant data28: STD_LOGIC_VECTOR (13 downto 0) := "01100000000110";

constant data29: STD_LOGIC_VECTOR (13 downto 0) := "00011110000000";

constant data30: STD_LOGIC_VECTOR (13 downto 0) := "00000001001001";

constant data31: STD_LOGIC_VECTOR (13 downto 0) := "01111100000001";

type rom_array is array (NATURAL range <>) of STD_LOGIC_VECTOR (13

downto 0);--arreglo del vector logico

constant rom: rom_array := (

data0, data1, data2, data3, data4, data5, data6, data7, data8, data9 ,
data10,data11,

data12, data13, data14, data15, data16, data17, data18, data19, data20, data21,
data22,

data23, data24, data25, data26,data27, data28, data29,data30,data31

);

begin

process (addr)

variable j: integer;

begin

j := conv_integer(addr); --convirtiendo la contante a un entero

M <= rom(j);

end process;

end arq;

Implemetancion de una memoria SRAM

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

entity memoria_ff is port (

rst, clk : in STD_LOGIC; --Reset y CLR

ir : in STD_LOGIC_VECTOR (3 downto 2); -- es de 2 bits

dm_in : in STD_LOGIC_VECTOR (3 downto 0);-- vector de entrada de datos (4

bits)

sto_dm : in STD_LOGIC;-- Señal para habilitar la transferencia

dm_value : out STD_LOGIC_VECTOR (3 downto 0)--Salida (buffer de lectura) (4

bits)

);

end memoria_ff;

architecture arq of memoria_ff is

signal DEC_OUT: STD_LOGIC_VECTOR(3 downto 0);

signal CE: STD_LOGIC_VECTOR(3 downto 0);

--signal dec_out,ce: std_logic_vector (3 downto 0);

signal q0: std_logic_vector (3 downto 0);

signal q1: std_logic_vector (3 downto 0);

signal q2: std_logic_vector (3 downto 0);

signal q3: std_logic_vector (3 downto 0);

begin

--decoder

--Basada en una tabla de verdad

DEC_OUT(0) <= not ir(3) and not ir(2);

DEC_OUT(1) <= not ir(3) and ir(2);

DEC_OUT(2) <= ir(3) and not ir(2);

DEC_OUT(3) <= ir(3) and ir(2);

--And con entrada sto_dm y vector dec_out

CE(0) <= STO_DM AND DEC_OUT(0);

CE(1) <= STO_DM AND DEC_OUT(1);

CE(2) <= STO_DM AND DEC_OUT(2);

CE(3) <= STO_DM AND DEC_OUT(3);

--flip-flops:

--flip flops

process(CE, CLK, RST)

begin

if (rst='1') then q0 <= "0000";

elsif(CE(0)='1') and rising_edge (clk) then q0 <= DM_IN;

end if;

if (rst='1') then q1 <= "0000";

elsif(CE(1)='1') and rising_edge (clk) then q1 <= DM_IN;

end if;

if (rst='1') then q2 <= "0000";

elsif(CE(2)='1') and rising_edge (clk) then q2 <= DM_IN;

end if;
 if (rst='1') then q3 <= "0000";

elsif(CE(3)='1') and rising_edge (clk) then q3 <= DM_IN;

end if;

--elseif (CLK)

end process;

--MUX

dm_value <= q0 when ir(3 downto 2)="00" else

q1 when ir(3 downto 2)="01" else

q2 when ir(3 downto 2)="10" else

q3 when ir(3 downto 2)="11";

end arq;
Referencicas:
teorico, N. d. (n.d.). Retrieved from
https://www.fing.edu.uy/tecnoinf/mvd/cursos/arqcomp/material/teo/arq-teo09.pdf

[1] Digilent, Digilent Nexys 4, Board Reference Manual, Digilent, Inc., July
2021. https://store.digilentinc.com/nexys-4-artix-7-fpga-trainer-board-limitedtime-
see-nexys4-ddr/