Multiplexorul. Bufferul. Memoria de program. Memoria de date Latch-ul.

Multiplexorul. Bufferul. Memoria de program. Memoria de date Latch-ul.

Obiective

Insusirea modului de lucru cu limbajul VHDL

- Realizarea memoriei de program si memoriei de date

- Intelegerea modului de functionare a multiplexorului, buffer-ului,

latch-ului si a memoriei de program si de date

Multiplexorul (MUX) este un circuit logic combinational care selecteaza una din intrarile sale pentru a o transmite la iesirea unica.

O declaratie a entitatii si arhitectura corpului pentru un multiplexor cu doua intrari este prezentata mai jos:

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.STD_LOGIC_ARITH.ALL;

use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity mux2 is

port (i0, i1 : in STD_LOGIC_VECTOR(3 downto 0);

y : out STD_LOGIC_VECTOR(3 downto 0);

sel : in STD_LOGIC);

end mux2;

architecture behaviour of mux2 is

begin

y <= i0 when sel = '0' else i1;

end behaviour;

Entitatea are un bit de intrare selectat, doua intrari vectori de biti i0 si i1 si o iesire vector de biti y. Arhitectura corpului contine un semnal concurent care utilizeaza valoarea intrarii selectate pentru a determina care din cei doi vectori de biti de intrare vor fi trimisi catre iesire. Atribuirea este simtita de catre toate semnalele de intrare, in asa fel incat daca unul dintre ele se modifica, aceasta va continua.

Bufferul

Entitatea are un bit de intrare activat en, un vector de biti de intrare a si un vector de biti de iesire b. Nu este posibil sa facem aceasta entitate generica respectand intrarea si iesirea portului width, din cauza unei limitari impuse de semantica limbajului VHDL. Portul de iesire trebuie sa fie un semnal remis.

In scopul de a face buffer-ul portului width generic, va trebui sa specificam o functie de rezolutie a magistralei care ia ca parametru un sir de elemente fara restrictii ale carui dimensiune este necunoscuta. VHDL nu permite ca tipul elementelor unui sir fara restrictii sa fie o multime fara restrictii, asa ca aceasta abordare este imposibila.

Comportamentul buffer-ului este implementat de catre un proces sensibil la intrarile en si a. Daca en este '1', intrarea a este transmisa catre iesirea b. Daca en este '0', driver-ul pentru b este deconectat si valoarea lui a este ignorata.

Referat: Contabilitatea tertilor Referat: Structurarea elementelor de activ si pasiv dupa criterii financiare

entity buffer_32_1 is

port (a : in STD_LOGIC_VECTOR(15 downto 0);

b : out STD_LOGIC_VECTOR(15 downto 0);

en : in STD_LOGIC);

end buffer_32_1;

architecture behaviour of buffer_32_1 is

begin

b_driver: process (en, a)

begin

if en = '1' then

b <= a;

-- else

--b <= X'0000';

end if;

end process b_driver;

end behaviour;

Memoria de program

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.STD_LOGIC_ARITH.ALL;

use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity memory_prog is

port (dpo_bus : out STD_LOGIC_VECTOR(15 downto 0);

a_bus : in STD_LOGIC_VECTOR(9 downto 0);

ce : in STD_LOGIC;

pready : out STD_LOGIC);

end memory_prog;

architecture bhv of memory_prog is

type memory_array_prog is array (0 to 255) of STD_LOGIC_VECTOR(15 downto 0);

constant mem_prog : memory_array_prog := (

----- ----- ------------programul principal-------- ----- ------ --

0 => X'4301',--start:adi r3, r0, 1; registrul r3 ia valoarea 1

1 => X'4202',-- adi r2, r0, 2

2 => X'0123',-- ad r1, r2, r3

3 => X'D100', -- st r1, r0, IO(0x0000); se incepe afisarea pe leduri

4 => X'0400', -- valoarea din r2

5 => X'FFF9', -- jump start: -- va intra intr-o bucla

others => (others => '0'));

begin

pready <= '1';

process (ce, a_bus) is

begin

if ce = '1' then

dpo_bus <= mem_prog(conv_integer(a_bus));

end if;

end process;

end architecture bhv;

Dupa cum se poate observa in acest caz, aceasta memorie este de tip ROM, adica este scrisa si nu mai poate fi rescrisa.

Se declara un proces care sa asculte intrarile a_bus si ce. Bus-ul a_bus ne spune ce instructiune se va extrage din variabila memory_prog (care este de tipul array).

Memoria de date

entity memory_data is

port (di_bus : in STD_LOGIC_VECTOR(15 downto 0);

ddo_bus : out STD_LOGIC_VECTOR(15 downto 0);

a_bus : in STD_LOGIC_VECTOR(9 downto 0);

nce : in STD_LOGIC;

rd, wr : in STD_LOGIC;

dready : out STD_LOGIC);

end memory_data;

architecture bhv of memory_data is

type memory_array_data is array (0 to 31) of STD_LOGIC_VECTOR(15 downto 0);

begin

dready <= '1';

process (nce, rd, wr, di_bus, a_bus) is

variable mem_data : memory_array_data;

begin

if nce = '0' then

if rd = '1' then

ddo_bus <= mem_data(conv_integer(a_bus));

end if;

if wr = '1' then

-- mem_data(address) := di_bus;

case a_bus is

when B'0000000000' =>

mem_data(0) := di_bus;

when B'0000000001' =>

mem_data(1) := di_bus;

when B'0000000010' =>

mem_data(2) := di_bus;

when B'0000000011' =>

mem_data(3) := di_bus;

when B'0000000100' =>

mem_data(4) := di_bus;

when B'0000000101' =>

mem_data(5) := di_bus;

when B'0000000110' =>

mem_data(6) := di_bus;

when B'0000000111' =>

mem_data(7) := di_bus;

when B'0000001000' =>

mem_data(8) := di_bus;

when B'0000001001' =>

mem_data(9) := di_bus;

when B'0000001010' =>

mem_data(10) := di_bus;

when B'0000001011' =>

mem_data(11) := di_bus;

when B'0000001100' =>

mem_data(12) := di_bus;

when B'0000001101' =>

mem_data(13) := di_bus;

when B'0000001110' =>

mem_data(14) := di_bus;

when B'0000001111' =>

mem_data(15) := di_bus;

when B'0000010000' =>

mem_data(16) := di_bus;

when B'0000010001' =>

mem_data(17) := di_bus;

when B'0000010010' =>

mem_data(18) := di_bus;

when B'0000010011' =>

mem_data(19) := di_bus;

when B'0000010100' =>

mem_data(20) := di_bus;

when B'0000010101' =>

mem_data(21) := di_bus;

when B'0000010110' =>

mem_data(22) := di_bus;

when B'0000010111' =>

mem_data(23) := di_bus;

when B'0000011000' =>

mem_data(24) := di_bus;

when B'0000011001' =>

mem_data(25) := di_bus;

when B'0000011010' =>

mem_data(26) := di_bus;

when B'0000011011' =>

mem_data(27) := di_bus;

when B'0000011100' =>

mem_data(28) := di_bus;

when B'0000011101' =>

mem_data(29) := di_bus;

when B'0000011110' =>

mem_data(30) := di_bus;

when B'0000011111' =>

mem_data(31) := di_bus;

when others => null;

end case;

end if;

end if;

end process;

end architecture bhv;

Memoria de date actioneaza ca un buffer si detine tot ceea ce este copiat din memorie gata pentru a fi utilizat de catre procesor.

LATCH-UL

Latch proiectat cu logica combinationala

Latch-ul reprezinta un multiplexor pentru care semnalul de selectie este semnalul de ceas.

Latch-ul la fel ca si buffer-ul faciliteaza interfatarea cu memoria si cu unitatea de comanda si control.

entity latch_1 is

port (d : in STD_LOGIC_VECTOR(15 downto 0);

q : out STD_LOGIC_VECTOR(15 downto 0);

en : in STD_LOGIC);

end latch_1;

architecture behaviour of latch_1 is

begin

process (d, en)

begin

if en = '1' then

q <= d;

end if;

end process;

end behaviour;