Integrantes:

Castañedo Hernández Juan Eduardo

Fajardo Aguirre José Ignacio
Terán León Fernando Rafael
Práctica 6

Unidad de aprendizaje: Dispositivos lógicos programables

Grupo: 2MM15

Profesor: Suárez Tapia Julio Cesar

Fecha de entrega: 25/11/2019

Contenido
Introducción ........................................................................................................................................ 3
Memoria RAM ................................................................................................................................. 3
Memoria ROM ................................................................................................................................. 3
Desarrollo ............................................................................................................................................ 5
Momoria RAM ................................................................................................................................. 5
Código en VHDL memoria RAM .................................................................................................. 5
Memoria ROM ............................................................................................................................... 12
Código en VHDL memoria ROM ................................................................................................ 12
Conclusiones ..................................................................................................................................... 14
Introducción

Memoria RAM

Acrónimo de Random Access Memory, o Memoria de Acceso Aleatorio, es un tipo

de memoria operativa de los computadores y sistemas informáticos, adonde va a
ejecutarse la mayor parte del software: el propio sistema operativo, el software de
aplicación y otros programas semejantes.
La memoria RAM además es una forma de memoria temporal, que al apagar o
reiniciar el sistema vuelve a estar en blanco. Esto considerando que al inicio del
sistema los módulos básicos de funcionamiento (como el POST o el BIOS), inscritos
a menudo en ROM, hacen un chequeo de la memoria RAM para asegurarse de que
esté operativa y se pueda volcar en ella el software necesario para iniciar el sistema.

Memoria ROM

El primer tipo de memoria no volátil que se describirá es MP-ROM (memoria de solo

lectura programada por máscara), que se programa durante la fabricación. Una
ROM 4 × 3 (4 palabras de 3 bits cada una
Esta es una ROM de tipo NOR porque cada columna es una puerta NOR (en este
ejemplo se empleó una arquitectura pseudo-nMOS.
Considerando las salidas después de los inversores, la presencia de un transistor
corresponde a un '1', mientras que su ausencia representa un '0'. Una construcción
común El enfoque para este tipo de ROM es tener un transistor fabricado en cada
nodo, luego hacer que la máscara de interconexión final seleccione cuáles deben
participar efectivamente en el circuito.
Para seleccionar una palabra en la Figura 1 (a), se aplica un '1' (VDD) a la línea de
palabra (WL) correspondiente con todos los otros WL en 0 V. Suponga que se ha
seleccionado WL0; entonces los voltajes de las líneas de bits BL2 y BL1 son bajado
por los transistores nMOS, mientras que el de BL0 permanece alto debido al
transistor pMOS pull-up. Por lo tanto, después de los inversores, la salida es "110".
Se enumeran las cuatro palabras almacenadas en este MP-ROM de tipo NOR en la
figura 1 (c). Tenga en cuenta que para convertir los N bits de dirección en líneas de
2N palabras, un decodificador de dirección (Sección 11.5) es necesario, lo que no
está incluido en la Figura 1 (a).
Una implementación ROM lógicamente equivalente se muestra en la Figura 1 (b).
Este es un MP-ROM tipo NAND porque cada columna es una puerta NAND. La
selección de palabras se realiza con un '0', mientras se mantiene todos los otros WL
en '1'. Si consideramos nuevamente las salidas después de los inversores, ahora la
presencia de un transistor es un '0', mientras que su ausencia es un '1'. La ventaja
de este enfoque es que los transistores nMOS son directamente conectados entre
sí, sin tierra ni ningún otro contacto en el medio, ahorrando así espacio de silicio
sobre él.

Por otro lado, la constante de tiempo grande asociada con la larga pila de
transistores causa la memoria NAND ser más lento para acceder que su contraparte
NOR.

Fig. 1 (a) matriz de pseudo-nMOS 4 × 3 tipo NOR MP-ROM; (b) Pseudo-nMOS de tipo NAND equivalente
Conjunto de MP-ROM; (c) contenido de la memoria; (d) Implementación utilizando puertas convencionales.
Desarrollo

Memoria RAM
En la práctica el objetivo era, desarrollar una memoria RAM, la cual pudiera almacenar números
en código ASCCI, para posteriormente, mostrarlos en un display de 7 segmentos. A continuación,
en la ilustración1 se muestra el diagrama de bloques para el funcionamiento del sistema.

Ilustración 1 Diagrama de bloques

Utilizando una capacidad de memoria de 15 localidades, se utilizaron los switch para ingresar una
palabra en ASCII, un botón fue designado para cambiar la localidad a la que se ingresa y dos switch
son los encargados de seleccionar la modalidad de escritura o lectura.

Una vez ingresado el valor en la memoria, este se verá reflejado (ya sea en modo escritura o
lectura) en el display de 7 segmentos.

A continuación, se anexa el código correspondiente al desarrollo de la memoria RAM.

Código en VHDL memoria RAM

----------------------------------------------------------------------------------
-- Company:
-- Engineer:
--
-- Create Date: 31.10.2019 07:27:23
-- Design Name:
-- Module Name: RAM - Behavioral
-- Project Name:
-- Target Devices:
-- Tool Versions:
-- Description:
--
-- Dependencies:
--
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
----------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use ieee.std_logic_unsigned.all;
-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if instantiating

-- any Xilinx leaf cells in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity RAM is
Port ( clk : in std_logic;
btn_in : in std_logic;
sw1: in std_logic_vector(3 downto 0);
sw2: in std_logic_vector(7 downto 0);
w:in std_logic;
r:in std_logic;
anod: out std_logic_vector(7 downto 0);
segm:out std_logic_vector(7 downto 0);
btn_out : out std_logic );
end RAM;

architecture Behavioral of RAM is

constant CNT_SIZE : integer := 19;
signal btn_prev : std_logic := '0';
signal counter : std_logic_vector(CNT_SIZE downto 0) := (others => '0');
signal btn: std_logic;
signal baff: std_logic_vector(7 downto 0);
signal state: std_logic_vector(3 downto 0);
signal m1: std_logic_vector(7 downto 0):="00000000";
signal m2: std_logic_vector(7 downto 0):="00000000";
signal m3: std_logic_vector(7 downto 0):="00000000";
signal m4: std_logic_vector(7 downto 0):="00000000";
 signal m5: std_logic_vector(7 downto 0):="00000000";
signal m6: std_logic_vector(7 downto 0):="00000000";
signal m7: std_logic_vector(7 downto 0):="00110111";
signal m8: std_logic_vector(7 downto 0):="00000000";
signal m9: std_logic_vector(7 downto 0):="00000000";
signal m10: std_logic_vector(7 downto 0):="00000000";
signal m11: std_logic_vector(7 downto 0):="00000000";
signal m12: std_logic_vector(7 downto 0):="00000000";
signal m13: std_logic_vector(7 downto 0):="00000000";
signal m14: std_logic_vector(7 downto 0):="00000000";
signal m15: std_logic_vector(7 downto 0):="01001001";
begin
------------------------------------------------------------------
process(clk)
begin
if (clk'event and clk='1') then
if (btn_prev xor btn_in) = '1' then
counter <= (others => '0');
btn_prev <= btn_in;
elsif (counter(CNT_SIZE) = '0') then
counter <= counter + 1;
else --- ANTIREBOTE
btn_out <= btn_prev;
btn<= btn_prev;

end if;
end if;
end process;
--------------------------------------------------------------------------
estado:process(btn,sw1)
begin
if (btn'event and btn='1') then

state<=sw1; -- LOCALIDAD
end if;
end process estado;
--------------------------------------------------------------------------

WR: process(state,w,r,sw2)
begin
case(state)is

when "0001"=>
if (w='1'and r='0') then
m1<=sw2;
baff<=sw2;
else if(w='0'and r='1') then
 m1<=m1;
baff<=m1;

end if;
end if;
when "0010"=>
if (w='1'and r='0') then
m2<=sw2;
baff<=sw2;
else if(w='0'and r='1') then
m2<=m2;
baff<=m2;

end if;
end if;
when "0011"=>
if (w='1'and r='0') then
m3<=sw2;
baff<=sw2;
else if(w='0'and r='1') then
m3<=m3;
baff<=m3;

end if;
end if;
when "0100"=>
if (w='1'and r='0') then
m4<=sw2;
baff<=sw2;
else if(w='0'and r='1') then
m4<=m4;
baff<=m4;

end if;
end if;
when "0101"=>
if (w='1'and r='0') then
m5<=sw2;
baff<=sw2;
else if(w='0'and r='1') then
m5<=m5;
baff<=m5;

end if;
end if;
when "0110"=>
if (w='1'and r='0') then
m6<=sw2;
 baff<=sw2; --- Escritura/lectura
else if(w='0'and r='1') then
m6<=m6;
baff<=m6;

end if;
end if;
when "0111"=>
if (w='1'and r='0') then
m7<=sw2;
baff<=sw2;
else if(w='0'and r='1') then
m7<=m7;
baff<=m7;

end if;
end if;
when "1000"=>
if (w='1'and r='0') then
m8<=sw2;
baff<=sw2;
else if(w='0'and r='1') then
m8<=m8;
baff<=m8;

end if;
end if;
when "1001"=>
if (w='1'and r='0') then
m9<=sw2;
baff<=sw2;
else if(w='0'and r='1') then
m9<=m9;
baff<=m9;

end if;
end if;

when "1010"=>

if (w='1'and r='0') then

m10<=sw2;
baff<=sw2;
else if(w='0'and r='1') then
m10<=m10;
baff<=m10;
 end if;
end if;
when "1011"=>
if (w='1'and r='0') then
m11<=sw2;
baff<=sw2;
else if(w='0'and r='1') then
m11<=m11;
baff<=m11;

end if;
end if;
when "1100"=>
if (w='1'and r='0') then
m12<=sw2;
baff<=sw2;
else if(w='0'and r='1') then
m12<=m12;
baff<=m12;

end if;
end if;
when "1101"=>
if (w='1'and r='0') then
m13<=sw2;
baff<=sw2;
else if(w='0'and r='1') then
m13<=m13;
baff<=m13;

end if;
end if;
when "1110"=>

if (w='1'and r='0') then

m14<=sw2;
baff<=sw2;
else if(w='0'and r='1') then
m14<=m14;
baff<=m14;

end if;
end if;
when "1111"=>
if (w='1'and r='0') then
m15<=sw2;
baff<=sw2;
 else if(w='0'and r='1') then
m15<=m15;
baff<=m15;

end if;
end if;

when others=>
m1<=m1;
m2<=m2;
m3<=m3;
m4<=m4;
m5<=m5;
m6<=m6;
m7<=m7;
m8<=m8;
m9<=m9;
m10<=m10;
m11<=m11;
m12<=m12;
m13<=m13;
m14<=m14;
m15<=m15;

end case;

end process WR;

------------------------------------------------------------------------------------------------------------------------------

segmen: process(baff)
begin
anod<="10111111";
case(baff) is
when "00110000" =>segm<="00000011";--0
when "00110001" =>segm<="10011111" ;--1
when "00110010" =>segm<="00100101" ;--2
when "00110011" =>segm<="00001101" ;--3
when "00110100" =>segm<="10011001" ;--4
when "00110101" =>segm<="01001001" ;--5
when "00110110" =>segm<="01000001" ;--6
when "00110111" =>segm<="00011111" ;--7
when "00111000" =>segm<="00000001" ;--8
when "00111001" =>segm<= "00001001"; --9
when "01000001" =>segm<= "00010001"; --A
when "01000101" =>segm<= "01100001"; --E
when "01001001" =>segm<= "10011110"; --I
when "01001110" =>segm<= "00000010"; --O
when "01010101" =>segm<= "10000011"; --U
 when others =>segm<= "11111111"; --U
end case;
end process segmen;

end Behavioral;

Memoria ROM
Para la realización de nuestra memoria ROM, se implementó un vector de 4 elementos para tener
acceso a las direcciones de memoria, así como de un vector compuesto de 15 elementos para
poder almacenar los 15 caracteres (vocales y números) .

A continuación, se muestra el código implementado en la FPGA (NEXYS 3) para nuestra memoria

Código en VHDL memoria ROM

----------------------------------------------------------------------------------
-- Company:
-- Engineer:
--
-- Create Date: 29.10.2019 08:07:21
-- Design Name:
-- Module Name: rom - Behavioral
-- Project Name:
-- Target Devices:
-- Tool Versions:
-- Description:
--
-- Dependencies:
--
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
----------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use ieee.std_logic_unsigned.all;
-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if instantiating

-- any Xilinx leaf cells in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity rom is
generic (bits: integer:=8);
Port (
address: in std_logic_vector(3 downto 0);
dataout: out std_ulogic_vector(bits-1 downto 0);
anodo: out std_logic_vector(3 downto 0));
end rom;

architecture Behavioral of rom is

type rom_array is array (0 to 14) of std_ulogic_vector (bits-1 downto 0);
-- los datos de los segmentos del display tienen el orden "abcdefgP" para ánodo común
constant rom: rom_array := (
"00000011", "10011111", "00100101", "00001101", -- 0, 1, 2, 3
"10011001", "01001001", "01000001", "00011111", -- 4, 5, 6, 7
"00000001", "00001001", "00010001", "01100001", -- 8, 9, A, E
"10011110", "00000010", "10000011"); -- I, O, U
signal addr: integer range 0 to 14;
begin
anodo <= "1110";
addr <= conv_integer(address); -- convierte el dato binario de address a entero
dataout <= rom(addr);

end Behavioral;
Conclusiones

Terán León Fernando Rafael: Las memorias hoy en día son la base del almacenamiento de la
información para todo tipo de dispositivo electrónico, por lo cual son un elemento imprescindible
en nuestra vida hoy en día. Al implementar la lógica con la que trabajan las memorias ROM y RAM,
nos es posible poder implementarlas de manera física mediante circuitos lógicos combinacionales,
ya sea con compuertas AND, NAND u OR.

Fajardo Aguirre José Ignacio: Para el desarrollo de esta práctica, se utilizó un programa con base en
el funcionamiento combinatorio, creemos posible mejorar el sistema y código, la complejidad de
este radicó en la comprensión del funcionamiento como tal de las memorias para posteriormente
plasmarlo en el sistema

Castañedo Hernández Juan Eduardo: Con la culminación de esta práctica se entendió sobre los
diferentes tipos de memorias que puede haber, las funciones que desempeña cada una y la
importancia que tienen, así mismo se aprendió de manera satisfactoria el debido diseño y la manera
apropiada en la que cada una de estas debe de ser programada para su correcto funcionamiento.