SISTEMAS DIGITAIS - Instituto Superior Técnico: Serviço...

SISTEMAS DIGITAIS TRABALHO DE LABORATÓRIO IV

CIRCUITO DE PROCESSAMENTO DE DADOS

RELATÓRIO

Identificação dos Alunos:

Nome: Diogo Morgado Número: 84032

Nome: Valter Piedade Número: 84195

Turno de Laboratório: SD4517L05 Grupo: 77

Sala do Laboratório: LSD1 Hora: 12h30 – 14h00

Nome do Docente: Aleksandar Ilic

SISTEMAS DIGITAIS 2015-2016, MEEC

2

1. Introdução

O objetivo deste quarto trabalho laboratorial de Sistemas Digitais é analisar e projectar um circuito

de processamento de dados constituído por elementos básicos de memória (registos) e módulos

combinatórios, através da análise minunciosa de cada um dos elementos constituíntes deste circuito de

processamento de dados.

O circuito servirá para realizar o ajuste da inclinação de um painel fotovoltaico, pelo que consistirá

num sistema de controlo que lê dados provenientes de um sensor de luz, que os processa e que atua

sobre o motor de inclinação de modo a otimizar a absorção de energia fornecida ao painel pela luz solar.

2. Projeto do circuito

Pergunta 1:

Figura 1 – Logigrama da parte da ALU que realiza as operações lógicas.

A simulação do funcionamento da ALU encontra-se na figura 4 da secção 3, juntamente com um

comentário acerca do resultado obtido.

Pergunta 2:

Figura 2 – Logigrama do circuito CTR_FF.

Inicialmente, o MUX 2:1 irá selecionar o cnt_in se o cnt_ld for ‘0’. Isto quer dizer que irá ocorrer

um Count que irá fazer a contagem tendo em conta o valor anterior. Se o cnt_ld for ‘1’, irá ocorrer um

Load que irá carregar o valor do d_in. De seguida o valor m que sai do MUX, irá realizar a operação lógica

AND2 com o sinal de reset. Isto irá fazer com que sempre que o sinal reset seja ‘0’, o q_out também seja

‘0’ e com que sempre que seja ‘1’ o q_out seja o valor de m. No final, o sinal a, que corresponde à saída

da AND2, irá entrar num Flip-Flop D. Este componente, como tem o seu enable constantemente a ‘1’, irá

transportar para a saída o valor de a apenas quando ocorrer o flanco ascendente do clock.


3

Pergunta 3:

Figura 3 – Diagrama temporal tendo em conta tempos de propagação de 20ns para os elementos de

memória, de 0ns para os restantes componentes e de 60ns para o período de relógio.

Pergunta 4:

A simulação completa deste circuito encontra-se representada na figura 5, presente na secção 3

deste relatório, tal como a sua comparação com o resultado esperado, que está representado na figura

3.

A forma de todos os sinais de controlo, depende dos valores de I(3:0), tal como é indicado na

tabela 4 do guia de laboratório. Os valores do I(3:0), por sua vez dependem dos valores do

CNTR_dout(3:0), que correspondem à saída do contador. Deste modo, quando o I(3:0)=”0000”, o RW_R0

será ‘0’e os sinais RW_TR, OP(1) e OP(0) serão ‘1’. Se I(3:0)=”0001”, o RW_R0 e o OP(0) serão ‘0’ e o

RW_TR será ‘1’ assim como o OP(1). Para os restantes valores de 4 bits, o RW_RO e o RW_TR são ‘0’ e os

valores OP(1) e OP(0) poderão ser ‘0’ ou ‘1’, pois o resultado que a ALU realizar não será escrito em

nenhum dos registos. A forma do sinal ALU_dout, está relacionada com a forma dos sinais de controlo

OP(1) e OP(0). Assim, o ALU_dout dependerá da operação realizada na ALU, que por sua vez depende

dos valores de OP(1) e OP(0), tal como é indicado na tabela 2 do guia de laboratório. Sempre que a forma

destes sinais de controlo for alterada, também a forma da ALU_dout se alterará por ser realizada uma

nova operação. No entanto, a alteração do valor do INSERT também alterou a forma deste sinal pois

mesmo sendo realizada a mesma operação em dois períodos de relógio consecutivos, a variação do

INSERT alterou uma das entradas da ALU, alterando assim o seu resultado, que corresponde à ALU_dout.

Na representação dos sinais RW_RO e RW_TR, apenas está presente uma única linha pois como

se tratam de sinais com apenas 1 bit, só podem ter duas representações, ou ‘1’ (linha superior) ou ‘0’

(linha inferior). Os sinais ALU_dout, OP(1) e OP(0), por sua vez, como se tratam de barramentos,

possuem na sua representação ambas as linhas preenchidas por serem sinais com mais do que 1 bit,

tendo por isso mais do que duas representações, sendo o seu valor escrito entre essas linhas.


4

3. Diagrama temporal e simulação do circuito

Através da análise da simulação do funcionamento da ALU (Figura 4), podemos concluir que o seu

valor final depende da operação realizada, que é selecionada pelos sinais OP(1) e OP(0). Foi nos possível

tirar esta conclusão pois os valores de X e Y são constantes durante toda a simulação, enquanto que os

valores da saída (d_out) vão alterando consoante os valores de OP(1:0) também alteram. As operações

realizadas estão presentes na tabela 2 do guia de laboratório.

Figura 4 – Simulação do funcionamento da ALU.

A simulação completa do circuito, que está representada na figura 5, corresponde ao esperado,

tal como se pode constatar por comparação ao diagrama temporal apresentado anteriormente na figura

3.

Este circuito, tem como função a realização de duas instruções, I1 e I2. A primeira corresponde

a um shift left (X<<1) ao valor obtido pelo sensor, que será guardado no registo TR, enquanto que a

segunda corresponde a uma adição desse valor com o inicial (X+Y). O resultado final será três vezes o

resultado inicial.

Assim, inicialmente, o INSERT possui o valor ‘1’ para que o valor obtido pelo sensor possa entrar

no circuito. A partir desse momento o INSERT toma sempre o valor ‘0’ (até ao final de todas as operações) para que os resultados das operações que estão a ser realizadas não sejam perdidos. O

contador, servirá para sequencializar as operações que serão efetuadas e o controlador para as indicar

aos registos e à ALU. Deste modo, quando as saídas do controlador forem “0000”, será realizado um shift

left do valor inicial, que será guardado no registo TR. De seguida, quando as saídas do controlador forem

“0001”, será realizada a adição do resultado do shift left com o valor inicial, que será guardado no registo

R0 e que dará o resultado final pretendido de três vezes o valor inicial. Podem-se observar mais

detalhadamente estas operações na tabela de controlo (tabela 4) presente no guia de laboratório.

Figura 5 – Simulação completa do circuito.


5

4. Implementação do circuito

Pergunta 5:

Neste circuito, o sinal de INIT encontra-se ligado ao reset e ao enable do contador. O CNTR_rst,

que é proveniente do INIT e se encontra ligado ao reset, encontra-se negado duas vezes, a primeira por

uma NOT e a segunda à entrada do contador. Quando o INIT se encontra a ‘0’, o reset também estará a

‘0’, pelo que irá ocorrer ou um Load ou um Count consoante o valor do INSERT. Por outro lado, se o INIT estiver a ‘1’, o reset também estará a ‘1’, o que irá fazer com que o contador fique com todas as suas

saídas a ‘0’. Deste modo, variar o valor do INIT entre 010, irá fazer com que o contador recomece a

contagem. Este recomeço de contagem irá implicar que a ALU realize a operação X<<1, que apenas seja

realizada a operação de leitura por parte registo R0 e que esse valor da operação realizada na ALU seja

escrito no registo TR.

Pergunta 6:

K0 : 84032/4 = 21008 digito menos significativo = 0 K0 = 0

K1 : 84195/4 = 21048.75 digito menos significativo = 0.75*4 = 3 K1 = 3

N0 = K0 + 1 = 1

N1 = K1 + 6 = 9

Para o contador começar a contagem em 1 e parar quando chegar a 9, é necessário alterar o valor

do CNTR_din (3:0) de “0000” para “0001”. Deste modo, quando ocorrer o Load, a contagem irá recomeçar,

mas a partir de 1. Para a contagem parar quando chegar a 9, é necessário retirar a ligação CNTR_ct15, e

substitui-la por uma ligação que carregue o valor da operação NAND2 entre CNTR_dout (2) e CNTR_dout

(1) e de uma AND3 entre o CNTR_dout (0), o CNTR_dout (3) e o valor obtido da NAND2. Esta ligação irá ser ligada na mesma posição onde se encontrava o CNTR_ct15. Estas operações irão proporcionar que

assim que se chegue ao valor “1001”, que corresponde ao número 9, a ligação possua o valor ‘1’, que irá

colocar o enable a ‘0’ pois este é o resultado de uma OR3 entre a negação desta nova ligação, do sinal de

INIT e do sinal de INSERT (estes dois últimos encontram-se a ‘0’). O enable a ‘0’ irá fazer parar o

contador.

Pergunta 7:

De modo a modificar o funcionamento da ALU para realizar as operações pretendidas,

verificámos que quando o OP(2)=’0’, são realizadas operações que são implementadas com recurso a

um somador. No entanto, o somador não é suficiente, pelo que foi necessário ligar, na segunda entrada

do somador uma AND2. A essa AND2 estava ligada uma XOR entre o Y e o OP(1) e na outra entrada da

AND2 estava ligado o OP(0). A primeira entrada do somador está ligada ao X e o Carry In ao OP(1). Assim

sendo, quando OP(1:0)=”00” será realizada uma transferência, quando OP(1:0)=”01” será realizada uma

soma, quando OP(1:0)=”10” será realizada um incremento e quando OP(1:0)=”11” será realizada uma

subtração. No caso de OP(2)=’1’, verificámos que são realizadas operações que não têm muito em


6

comum pelo que utilizámos um multiplexer 4:2. Nos seus bits de seleção colocámos o OP(0) como o bit

menos significativo e o OP(1) como o bit mais significativo, e nas suas entradas colocámos uma NAND2

entre o X e o Y (entrada 0), uma NOR entre o X e o Y (entrada 1), um shift left sobre o X (entrada 2) e um

shift right sobre o X (entrada 3). Assim quando OP(1:0)=”00” será realizada a NAND2, quando

OP(1:0)=”01” será realizada a NOR2, quando OP(1:0)=”10” será realizado um shift left e quando

OP(1:0)=”11” será realizado um shift right. Finalmente, colocámos um multiplexer 2:1 com o valor

proveniente do somador na entrada 0 e com o valor proveniente do multiplexer 4:1 na entrada 1, e com

o OP(2) como bit de seleção. Assim, quando OP(2)=’0’ será selecionado o valor proveniente do somador,

e quando OP(2)=’1’ será selecionado o valor proveniente do multiplexer 4:1.

O logigrama deste circuito encontra-se representado na figura 6.

Figura 6 – Logigrama da ALU modificada.

Pergunta 8:

A descrição da ALU da pergunta 7 em VHDL encontra-se em anexo no final do relatório (ponto1), tal

como o testbench (ponto 2), e a sua simulação encontra-se de seguida (figura 7).

Figura 7 – Simulação da ALU modificada.


7

Pergunta 9:

R0 S*2𝑝

P = K0 + 1 = 0+1 = 1

R0 2S

Tabela 1 – Processo para realizar a operação R0 2S.

Tabela 2 – Valores dos sinais de controlo, de forma a implementar o funcionamento descrito na tabela 1.

Pergunta 10:

Operações a realizar:

Operação 1 (OP1): TR R0 + TR;

Operação 2 (OP2): R0 R0<<1.

Tabela 3 – Tabela de controlo que realiza as operações OP1 e OP2.

Instrução ALU Operação Descrição Resultado Parcial

I1 X<<1 (SLA) R0 R0<<1 R0 2S

RW_R0 RW_TR OP(2) OP(1) OP(0)

1 0 1 1 0

Operação RW_R0 RW_TR OP(2) OP(1) OP(0) ALU Operação

OP1 0 1 0 0 1 X + Y OP2 1 0 1 1 0 X<<1


8

Pergunta 11:

R0 (3𝑆)∗2𝑝+1

2− 3𝑆

p = (K0 mod 2) + 1 = 0 + 1 = 1

R0 (3𝑆∗2)+1

2− 3𝑆

Tabela 4 – Tabela de controlo com as operações necessárias para modificar a função realizada para

R0 (3𝑆∗2)+1

2− 3𝑆.

Pergunta 12:

I(3:0) RW_R0 RW_TR OP(2) OP(1) OP(0) ALU Operação Descrição Resultado Parcial

0000 0 1 1 1 0 X<<1 (SLA) TRR0<<1 TR2S 0001 1 0 0 0 1 X + Y (ADD) R0TR+1 R03S 0010 0 1 0 0 0 X TRR0 TR3S 0011 1 0 1 1 0 X<<1 (SLA) R0TR<<1 R03S*2 0100 1 0 0 1 0 X + 1 (INC) R0R0+1 R03S*2+1 0101 1 0 1 1 1 X>>1 (SRA) R0R0>>1 R0

(3𝑆∗2)+1

2

0110 1 0 0 1 1 X – Y (SUB) R0R0-TR R0(3𝑆∗2)+1

2− 3𝑆

0111 0 0 X X X - NOP - 1000 0 0 X X X - NOP - 1001 0 0 X X X - NOP - 1010 0 0 X X X - NOP - 1011 0 0 X X X - NOP - 1100 0 0 X X X - NOP - 1101 0 0 X X X - NOP - 1110 0 0 X X X - NOP - 1111 0 0 X X X - NOP -

Figura 9 - Mapa de Karnaugh

do sinal de controlo RW_TR.

Figura 8 – Mapa de Karnaugh

do sinal de controlo RW_R0.

Figura 12 - Mapa de Karnaugh

do sinal de controlo OP(0). Figura 11 - Mapa de Karnaugh

do sinal de controlo OP(1). Figura 10 - Mapa de Karnaugh

do sinal de controlo OP(2).


9

RW_R0 𝐼3̅(𝐼2𝐼0̅ + 𝐼1̅𝐼0 + 𝐼2𝐼0̅);

RW_TR 𝐼3̅𝐼2̅𝐼1̅;

OP(2) 𝐼2̅𝐼1̅𝐼0̅ + 𝐼0(𝐼2 + 𝐼1);

OP(1) 𝐼1̅𝐼0̅ + 𝐼3̅𝐼2 + 𝐼1𝐼0;

OP(0) 𝐼1̅𝐼0 + 𝐼2𝐼1.

Figura 13 – Logigrama do novo controlador.

A modificação realizada ao ficheiro controlador.vhd em VHDL encontra-se em anexo no final do

relatório (ponto 3).

Pergunta 13:

A modificação realizada ao ficheiro lab4_circuito.vhd em VHDL encontra-se em anexo no final

do relatório (ponto 4).

Pergunta 14:

Figura 14 – Simulação completa do circuito modificado.

Expressões simplificadas a partir dos

mapas de Karnaugh de cada um dos sinais

de controlo.


10

Comentários Referentes à implementação do circuito:

Para implementar este circuito na placa de desenvolvimento Basys2, presente no laboratório,

tivemos de criar um símbolo para o componente lab4_circuit, e de seguida verificar todas as suas

ligações através do esquema sd.sch disponibilizado. Após a realização destas ligações, procedeu-se à

geração de um ficheiro sd.bit, que foi utilizado para implementar o circuito na placa de desenvolvimento.

Após ligarmos a placa de desenvolvimento, colocámos o SW0 a ‘1’, o SW1 a ‘1’, o SW2 a ‘0’ e o

SW3 a ‘1’, que corresponde ao valor lido pelo sensor, e constatámos que os valores que eram

apresentados na placa correspondiam aos resultados obtidos na simulação. Na figura 15, está presente

o resultado obtido na placa desenvolvimento quando o cntr_dout tinha o valor ‘5’.

Figura 15 – Resultado obtido na placa de desenvolvimento quando cntr_dout=5.

5. Conclusões

Na realização desta atividade laboratorial, foram encontradas algumas dificuldades pelo grupo

pois este trabalho era mais complexo em relação aos anteriores e por apresentar componentes

novos que ainda não tinham sido utilizados.

No entanto, consideramos que o grupo superou essas dificuldades conseguindo realizar todas as

tarefas propostas e, acima de tudo, ficámos a compreender melhor o funcionamento de circuitos de

processamento de dados.

Quanto aos resultados obtidos nas simulações efetuadas, estes foram em todos os casos

semelhantes aos esperados pelo grupo (alguns não à primeira tentativa devido a erros de escrita em

VHDL), e os resultados obtidos na placa de desenvolvimento também foram os esperados.


11

Anexo:

1) VHDL da ALU Modificada ----------------------------------------------------------------------------

------

-- Company:

-- Engineer:

--

-- Create Date: 15:04:07 11/05/2015

-- Design Name:

-- Module Name: alu - 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_ARITH.ALL;

use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating

---- any Xilinx primitives in this code.

--library UNISIM;

--use UNISIM.VComponents.all;

entity alu is

Port ( X : in STD_LOGIC_VECTOR (7 downto 0);

Y : in STD_LOGIC_VECTOR (7 downto 0);

op : in STD_LOGIC_VECTOR (2 downto 0);

D_out : out STD_LOGIC_VECTOR (7 downto 0));

end alu;

architecture Behavioral of alu is

COMPONENT somador_8bits

PORT(

P : IN std_logic_vector(7 downto 0);

Q : IN std_logic_vector(7 downto 0);

Cin : IN std_logic;

S : OUT std_logic_vector(7 downto 0);

Cout : OUT std_logic

);

END COMPONENT;

-- internal signals

signal op0_tmp, q_tmp, arit_out : std_logic_vector(7 downto 0);

signal lop0, lop1, logic_out : std_logic_vector(7 downto 0);

signal op1_tmp, fio1, fio2 : std_logic_vector(7 downto 0);

signal xor_tmp : std_logic_vector(7 downto 0);


12

begin

op0_tmp <= (others => op(0));

op1_tmp <= (others => op(1));

--xor

xor_tmp <= Y xor op1_tmp;

--and

q_tmp <= xor_tmp and op0_tmp;

-- somador 8-bits

Inst_somador_8bits: somador_8bits PORT MAP(

P => X,

Q => q_tmp,

Cin => op(1),

S => arit_out,

Cout => open

);

-- nand

lop0 <= X nand Y;

-- nor

lop1 <= X nor Y;

-- shift left

fio1 <= X(6 downto 0) & '0';

-- shift right

fio2 <= '0' & X(7 downto 1);

-- multiplexer

logic_out <= lop0 when op(1 downto 0)="00" else

lop1 when op(1 downto 0)="01" else

fio1 when op(1 downto 0)="10" else

fio2;

-- mux 2:1 at the end

D_out <= arit_out when op(2)='0' else logic_out;

end Behavioral;

2) VHDL do Teste Bench da ALU Modificada

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

----

-- Company:

-- Engineer:

--

-- Create Date: 15:18:21 11/05/2015

-- Design Name:

-- Module Name: /home/user/SD/Lab4/tb_alu.vhd

-- Project Name: Lab4

-- Target Device:

-- Tool versions:

-- Description:

--

-- VHDL Test Bench Created by ISE for module: alu

--


13

-- Dependencies:

--

-- Revision:



--

-- Notes:

-- This testbench has been automatically generated using types std_logic and

-- std_logic_vector for the ports of the unit under test. Xilinx recommends

-- that these types always be used for the top-level I/O of a design in

order

-- to guarantee that the testbench will bind correctly to the post-

implementation

-- simulation model.

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

----

LIBRARY ieee;

USE ieee.std_logic_1164.ALL;

USE ieee.std_logic_unsigned.all;

USE ieee.numeric_std.ALL;

ENTITY tb_alu IS

END tb_alu;

ARCHITECTURE behavior OF tb_alu IS

-- Component Declaration for the Unit Under Test (UUT)

COMPONENT alu

PORT(

X : IN std_logic_vector(7 downto 0);

Y : IN std_logic_vector(7 downto 0);

op : IN std_logic_vector(2 downto 0);

D_out : OUT std_logic_vector(7 downto 0)

);

END COMPONENT;

--Inputs

signal X : std_logic_vector(7 downto 0) := "00000001";

signal Y : std_logic_vector(7 downto 0) := "00001001";

signal op : std_logic_vector(2 downto 0);

--Outputs

signal D_out : std_logic_vector(7 downto 0);

BEGIN

-- Instantiate the Unit Under Test (UUT)

uut: alu PORT MAP (

X => X,

Y => Y,

op => op,

D_out => D_out

);

-- Stimulus process


14

stim_proc: process

begin

op <= "000";

wait for 100 ns;

op <= "001";

wait for 100 ns;

op <= "010";

wait for 100 ns;

op <= "011";

wait for 100 ns;

op <= "100";

wait for 100 ns;

op <= "101";

wait for 100 ns;

op <= "110";

wait for 100 ns;

op <= "111";

wait;

end process;

END;

3) VHDL do Controlador Modificado

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

------

-- Company:

-- Engineer:

--

-- Create Date: 15:43:50 11/05/2015

-- Design Name:

-- Module Name: controlador - Behavioral

-- Project Name:

-- Target Devices:

-- Tool versions:

-- Description:

--

-- Dependencies:

--

-- Revision:



--

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

------

library IEEE;






--library UNISIM;


entity controlador is


15

Port ( I : in STD_LOGIC_VECTOR (3 downto 0);

RW_R0 : out STD_LOGIC;

RW_TR : out STD_LOGIC;

OP : out STD_LOGIC_VECTOR (2 downto 0));

end controlador;

architecture Behavioral of controlador is

signal not0, not1, not2, not3 : std_logic;

signal and1_ro, and2_ro, and3_ro, or1_ro : std_logic;

signal and1_op2, and2_op2, or1_op2 : std_logic;

signal and1_op1, and2_op1, and3_op1 : std_logic;

signal and1_op0, and2_op0 : std_logic;

begin

not0 <= not I(0);

not1 <= not I(1);

not2 <= not I(2);

not3 <= not I(3);

--RW_RO

and1_ro <= not0 and I(2);



or1_ro <= and1_ro or and2_ro or and3_ro;

RW_R0 <= not3 and or1_ro;

--RW_TR

RW_TR <= not3 and not2 and not0;

--OP2

and1_op2 <= not2 and not1 and not0;

or1_op2 <= I(2) or I(1);

and2_op2 <= I(0) and or1_op2;

OP(2) <= and2_op2 or and1_op2;

--OP1

and1_op1 <= not1 and not0;

and2_op1 <= not3 and I(2);

and3_op1 <= I(1) and I(0);

OP(1) <= and1_op1 or and2_op1 or and3_op1;

--OP0

and1_op0 <= not1 and I(0);

and2_op0 <= I(2) and I(1);

OP(0) <= and1_op0 or and2_op0;

end Behavioral;


16

4) VHDL do Circuito Completo Modificado

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

------

-- Company:

-- Engineer:

--

-- Create Date: 15:51:08 11/05/2015

-- Design Name:

-- Module Name: lab4_circuit - Behavioral

-- Project Name:

-- Target Devices:

-- Tool versions:

-- Description:

--

-- Dependencies:

--

-- Revision:



--

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

------

library IEEE;






--library UNISIM;


entity lab4_circuit is

Port ( Init : in STD_LOGIC := '0';

Sensor : in STD_LOGIC_VECTOR (3 downto 0) := (others =>

'0');

Insert : in STD_LOGIC := '0';

clk : in STD_LOGIC;

Sens_out : out STD_LOGIC_VECTOR (7 downto 0);

Inst_out : out STD_LOGIC_VECTOR (3 downto 0));

end lab4_circuit;

architecture Behavioral of lab4_circuit is

COMPONENT register_8bits

PORT(

d_in : IN std_logic_vector(7 downto 0);

clk : IN std_logic;

r_w : IN std_logic;

d_out : OUT std_logic_vector(7 downto 0)

);

END COMPONENT;

COMPONENT alu

PORT(


17

X : IN std_logic_vector(7 downto 0);

Y : IN std_logic_vector(7 downto 0);

op : IN std_logic_vector(2 downto 0);

D_out : OUT std_logic_vector(7 downto 0)

);

END COMPONENT;

COMPONENT ctr_div16

PORT(

d_in : IN std_logic_vector(3 downto 0);

m : IN std_logic;

clk : IN std_logic;

rst_l : IN std_logic;

en : IN std_logic;

ct15 : OUT std_logic;

q_out : OUT std_logic_vector(3 downto 0)

);

END COMPONENT;

COMPONENT controlador

PORT(

I : IN std_logic_vector(3 downto 0);

RW_R0 : OUT std_logic;

RW_TR : OUT std_logic;

OP : OUT std_logic_vector(2 downto 0)

);

END COMPONENT;

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

-- internal signals --

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

-- temporary signals

signal sensor_ext : std_logic_vector(7 downto 0);

-- ALU

signal ALU_dout : std_logic_vector(7 downto 0);

-- Registers R0 and TR

signal R0_din : std_logic_vector(7 downto 0);

signal R0_rw : std_logic;

signal R0_dout, TR_dout : std_logic_vector(7 downto 0);

-- Controlador (CDOR) outputs

signal CDOR_rw_r0, CDOR_rw_tr : std_logic;

signal CDOR_op : std_logic_vector(2 downto 0);

-- Counter div16 (CNTR)

signal CNTR_rst, CNTR_m : std_logic;

signal CNTR_en : std_logic;

signal CNTR_din : std_logic_vector(3 downto 0);

signal CNTR_dout : std_logic_vector(3 downto 0);

signal ct7 : std_logic;

begin

-- sign extension

sensor_ext <= Sensor(3) & Sensor(3) & Sensor(3) & Sensor(3) & Sensor(3

downto 0);

---- REGISTER 0 (R0) ----

-- mux 2:1

R0_din <= sensor_ext when Insert='1' else ALU_dout;


18

-- or2 on RW for R0

R0_rw <= Insert or cdor_rw_r0;

-- R0

R0: register_8bits PORT MAP(

d_in => R0_din,

clk => clk,

r_w => R0_rw,

d_out => R0_dout

);

-- output: SENS_OUT

Sens_out <= R0_dout;

---- TEMPORARY REGISTER (TR) ----

TR: register_8bits PORT MAP(

d_in => ALU_dout,

clk => clk,

r_w => CDOR_rw_tr,

d_out => TR_dout

);

---- ALU ----

ALU1: alu PORT MAP(

X => R0_dout,

Y => TR_dout,

op => CDOR_op,

D_out => ALU_dout

);

---- COUNTER DIV16 ----

-- counter reset

CNTR_rst <= (not Init);

-- counter enable

ct7 <= not(not CNTR_dout(3) and CNTR_dout(2) and CNTR_dout(1)and

CNTR_dout(0));

CNTR_en <= Insert or Init or ct7;

-- counter mode select

CNTR_m <= Insert;

-- counter data in

CNTR_din <= "0000";

-- contador CNTR

CNTR: ctr_div16 PORT MAP(

d_in => CNTR_din,

m => CNTR_m,

clk => clk,

rst_l => CNTR_rst,

en => CNTR_en,

ct15 => open,

q_out => CNTR_dout

);

-- output: INST_OUT

Inst_out <= CNTR_dout;

---- CONTROLADOR (CDOR) ----

CDOR: controlador PORT MAP(


19

I => CNTR_dout,

RW_R0 => CDOR_rw_r0,

RW_TR => CDOR_rw_tr,

OP => CDOR_op

);

end Behavioral;

SISTEMAS DIGITAIS - Instituto Superior Técnico: Serviço...

Documents

Transcript of SISTEMAS DIGITAIS - Instituto Superior Técnico: Serviço...