Laboratório 4 RELATÓRIO - Instituto Superior Técnico...

1

SISTEMAS DIGITAIS Laboratório 4

RELATÓRIO

Identificação dos Alunos:

Nome:Gonçalo Santos

Número:84070

Nome:Bernardo Bastos

Número: 84012

Turno de Laboratório: SD4517L05

Grupo: 73

Sala do Laboratório: LSD1

Hora: 12:30-14:00

Nome do Docente: Aleksandar Ilic

2

1.INTRODUÇÃO O objetivo deste trabalho laboratorial foi a elaboração de um circuito de computação para realizar o

ajuste da inclinação de um painel solar fotovoltaico. Assim, o circuito de computação consiste num sistema

de controlo que lê os dados provenientes do sensor de luz (sensor presento no painel), processa-os e atua

sobre o motor de inclinação de forma a otimizar a absorção de energia solar por parte do painel.

2. PROJETO DO CIRCUITO Respostas às perguntas da Secção 2.

1. Apresente a logigrama da parte da ALU que realiza as operações lógicas, tendo por

base a descrição VHDL fornecida em alu.vhd (incluindo todos os sinais externos e

internos, portas lógicas, componentes e largura em bits de cada ligação). Verifique

o funcionamento da ALU através de uma simulação. Utilize o testbench

especificado no ficheiro tb_alu.vhd para o efeito.

Analisámos o funcionamento da

ALU e baseando-nos no ficheiro

VHDL construímos o seguinte

logigrama da parte que

corresponde à realização das

operações lógicas.

Através da análise da simulação

obtida, conseguimos verificar que a operação a realizar para cada um dos valores de Op era a pretendida.

2. Apresente a logigrama do circuito CTR_FF, tendo por base a descrição em VHDL

fornecida em ctr_ff.vhd (incluindo todos os sinais externos e internos, portas lógicas,

componentes e largura em bits de cada ligação). Explique sucintamente qual é a

função dos componentes dentro do CTR_FF.

Analisámos o circuito CTR_FF e a sua descrição em VHDL e elaborámos o logigrama correspondente.

FIGURA 1-LOGIGRAMA ALU-PARTE LÓGICA

FIGURA 2-LOGIGRAMA CTR_FF

3

Função dos componentes:

AND: Gerar o valor de a consoante os valores das entradas m e Rst_1. Quando a entrada Rst_1

está a 1, o valor de a é igual ao valor de m. Quando a entrada Rst_1 está a zero, o valor de a é

zero.

FF: O FF tipo D presente no contador tem como função transmitir o valor de a quando o CLK=1 e

EN=1. Quando o valor de EN é zero, a saída q_out é zero.

MUX: A saída m do MUX depende da entrada Cnt_ld. Assim, se o valor de Cn_t for zero, o valor de

m é igual ao valor de cnt_in, ou seja, o contador (CNT) continua a efetuar a contagem. Se o valor de

Cnt_ld for um, o valor de m vai ser igual ao valor de d_in fazendo assim load.

3. Preencha o diagrama temporal na página seguinte de acordo com a análise teórica e

a tabela de controlo acima fornecida. Considere que os elementos de memória (i.e.,

registos e contador) têm o tempo de propagação de 20ns, enquanto todos os outros

componentes (i.e., ALU, controlador, multiplexers e portas lógicas) têm o tempo de

propagação de 0ns. Assuma também que o período do relógio é de 60ns.

Elaborou-se o diagrama temporal do circuito analisando o funcionamento dos componentes

presentes.

FIGURA 3-DIAGRAMA TEMPORAL

4

4. Faça a simulação completa do circuito da Figura 2 (o testbench é fornecido no

ficheiro tb_lab4_circuito.vhd) e compare o resultado esperado (apresentado no

diagrama temporal) com o resultado obtido através da simulação no XILINX ISE.

Apresente a simulação no relatório, incluindo todos os sinais (na mesma ordem

apresentada no diagrama temporal) e comente o resultado. Explique sucintamente a

forma da onda dos sinais ALU_dout e dos todos os sinais de controlo (i.e., as saídas

do controlador).

Elaborou-se a simulação do circuito, usando o ficheiro testbench, obtendo-se assim o diagrama

abaixo representado:

Através da análise dos dois diagrama temporais, verificou-se que estes são semelhantes. A

única diferença reside no facto de o diagrama elaborado à mão tem em consideração os tempos de

propagação dos elementos de memória, isto é, registos e contadores (20ns). Para os restantes

componentes considerou-se que possuíam um tempo de propagação de 0ns.

Sinais de controlo:

Cdor_rw_tr: A função deste sinal é decidir se o resultado parcial é transferido para o registo TR.

Como tal, o registo TR só está ativo quando I tiver o valor de zero (0,0,0,0). Quando I tomar outros

valores, o registo TR está desativado. Logo a onda deste sinal só toma o valor 1 durante o estado

(0,0,0,0).

Cdor_rw_ro: Este sinal tem como função decidir se o registo R0, lê ou escreve um novo sinal. Como

não é necessário que o valor do sensor seja gravado no registo durante o estado I= (0,0,0,0), este

sinal tem o valor de 0. No entanto, no estado I=(0,0,0,1) este sinal tem o valor de 1, realizando-se

assim a operação 3S pois o valor de X passa a ser S. Logo, a onda deste sinal é 0 enquanto

I=(0,0,0,0), 1 enquanto I=(0,0,0,1) e zero durante os restantes estados.

Cdor_op: Decide a operação a realizar pela ALU. Durante o estado 0000, este sinal tem o valor 11,

efetuando multiplicação por dois do valor de X sendo o resultando final 2X. No estado seguinte, 0001,

este sinal toma o valor 01, realizando a soma do resultado obtido anteriormente com X, sendo o

resultado final 3X. Nos outros estados o valor de deste sinal é irrelevante viste que a operação é

realizada mas não influência a saída final do circuito.

Alu_dout: A onda do sinal toma o valor equivalente a 2X durante o estado I=(0,0,0,0). No estado I=

(0,0,0,1), o sinal toma o valor equivalente a 3X. Os restantes valores deste sinal, ou seja, os valores

para os outros estados não interessam visto que não influenciam as saídas finais do circuito.

FIGURA 4-SIMULAÇÃO LAB 4 CIRCUITO

5

5. Antes de iniciar a execução das diversas instruções, bem como a ativação de

qualquer outro sinal do circuito, é necessário pulsar o sinal INIT, variando o seu valor

entre 0→1→0. Justifique a necessidade deste procedimento, explicando o seu efeito

nos diferentes componentes do circuito.

É necessário que o valor de INIT varie entre 010 para que seja possível reiniciar o processo de

contagem, tornando assim possível, de novo, a realização das operações de soma e multiplicação. No

contador, o sinal INIT faz com que este volte a ler todos os estados novamente pois efetua reset

reiniciando-se assim o processo de contagem.

6. Sem fazer qualquer modificação ao código VHDL fornecido, explique (no relatório)

como se pode modificar o contador CNTR de modo a começar a contagem de valor

N0 e a parar a mesma quando chega a N1, onde: • N0=K0+1 (K0 é o digito menos

significativo (em base 4) do numero de aluno de menor valor) e • N1=K1+6 (K1 é o

digito menos significativo (em base 4) do numero de aluno de maior valor).

Cálculo N0:

84012/4=21002 Resto=0=K0

0+1= 100012

Cálculo N1:

840704=21017 Resto=2=K1

2+6=810002

Ao ligarmos a saída do contador correspondente ao bit de maior peso à porta OR que ativa e desativa o

contador, quando este tiver o valor de 1, que corresponde ao número 8 em binário (1,0,0,0).O EN irá assim

ser zero, pois a entrada da OR a que se liga o fio está negada o que faz com que o contador pare de contar.

O EN está ativo para os estados anteriores pois o valor do bit de maior peso é sempre 0.

7. Modifique o funcionamento da unidade aritmética e lógica (ALU) de modo a poder

executar o conjunto das operações indicado na tabela em baixo. Apresente todos os

passos de projeto do circuito e o logigrama da ALU obtida (semelhante ao que está

apresentado na Figura 4).

De forma a fazer com que a ALU realizasse as

operações presentes na tabela de verdade dada

tivemos que alterar o seu funcionamento interno.

FIGURA 5-LOGIGRAMA CONTADOR

FIGURA 6-TABELA DE VERDADE DAS OPERAÇÕES DA ALU

6

Verificou-se que para que a nova ALU realiza-se as operações pretendidas era necessário aumentar

o número de bits do sinal OP para 3. Após realizar-se este passo, começou-se por definir o bit OP(2) como o

bit de seleção do Multiplexer final, fazendo com que este selecione se o resultado final da ALU resulta de uma

operação lógica, logic_out OP(2)=1, operação aritmética, arit_out OP(2)=1, ou operação de transferência.

Para realizar a parte aritmética, verificou-se que o valor de Cin do somador

de 8 bits correspondia ao valor de OP(1), como tal atribuímos o valor de OP(1) ao

carry in do somador. Ao analisar-se cada umam das operações, verificou-se que a

variável X nunca se alterava e que apenas era necessário alterar o valor de Y. Como

tal recorremos a mapas de karnaugh e obtivemos e implementamos a seguinte

expressão simplificada:

Para realizar a parte lógica, utilizou-se um multiplixer 4:1 em que

os seus bits de seleção são OP(1) e OP(0). Para cada um destes

valores, modificamos as entradas do multiplexer para que este

realizasse a operação pretendida para cada um dos valore de OP(1:0).

Para realizar a operação de divisão por 2 fez-se um shit aritmético right,

correspondente ao sinal lop3, para realizar a operação de multiplicação

por 2 fez-se um shift aritmético left, correspondente ao sinal lop2. Os

sinais lop1 e lop1 2 correspondem às operações X NAND Y e X NOR Y,

respetivamente.

Completámos assim o logigrama com a lógica necessária para

fazer com que a ALU realizasse as operações desejadas obtendo assim

o logigrama seguinte.

8. Descreva a ALU projetada em VHDL, alterando para esse propósito o ficheiro

fornecido (i.e., alu.vhd). Adapte o testbench (i.e., tb_alu.vhd) e simule o

funcionamento completo da ALU modificada (i.e., para todas as operações). Utilize o

valor N0 para a entrada X e o valor N1 para a entrada Y.

Com o objetivo de implementar as operações aritméticas, lógicas e de transferência, alterámos o ficheiro

alu.vhd que consta em anexo no final do relatório. Simulámos o seu funcionamento através do ficheiro

tb_alu.vhd e verificámos que esta realizava as operações de acordo com as instruções dadas e de acordo

com a tabela de verdade do ficheiro alu.vhd.

FIGURA 9-LOGIGRAMA ALU MODIFICADA

FIGURA 7-MAPA DE KARNAUGH DE

Y

FIGURA 8-TABELA DE VERDADE DA ALU

MODIFICADA

7

9. Para se poder utilizar um algoritmo de ajuste da inclinação do painel solar mais

sofisticado, é necessário modificar a função realizada pelo circuito de computação.

Para esse efeito, pretende-se que o circuito passe a realizar a operação R0 ← S ∗ 2/

(em vez de R0 ← 3S), onde o valor de p corresponde a K0+1. Preencha a tabela em

baixo, indicando como se pode realizar esta operação com o circuito fornecido.

Valor de K0=0 K0+1=1, logo R02S

Assim, a operação a realizar é um shift left aritmético que corresponde a uma multiplicação por 2.

Na Tabela em baixo indique os valores dos sinais de controlo, de forma a implementar o

funcionamento descrito:

Analisou-se o funcionamento da ALU e conclui-se que para realizar a operação desejada os sinais de

controlo tomam os seguintes valores:

10. Preencha a tabela de controlo (em baixo) de modo a realizar as seguintes duas

operações (considere que os valores já se encontram nos registos R0 e TR):

Para realizar a operação 1 que correspondia a TRR0+TR, atribui-se a Op(2:0) o valor de (0,0,1), a

RW_R0 o valor de 0, a RW_TR o valor de 0 para que a operação realizada pela ALU fosse R0+TR (X+Y).

Em relação à operação 2 que corresponde a R0R0<<1, atribuiu-se a Op(2:0) o valor de (1,1,0), a

RW_R0 o valor de 0 e como o valor de RW_TR o valor de X para que a operação realizada pela ALU fosse

R0<<1 (Shift Left aritmético).

11. Para implementar um algoritmo de ajuste ainda mais sofisticado, é necessário

modificar a função realizada para R0 ←((3S)∗2p+1)/2– 3S , onde o valor de p

corresponde a (K0 mod 2)+1.

K0=0 0mod2=0 0+1=1 p=1

FIGURA 10-TABELA INSTRUÇÕES

FIGURA 11-TABELA SINAIS CONTROLO

FIGURA 12-TABELA OPERAÇÕES 1 E 2

8

Analisámos o funcionamento da ALU modificada, do contador e dos funcionamentos dos registos

R0 E TR elaborámos a seguinte tabela de verdade com vista a implementar a operação:

R0((3S)*2+1)/-3S.

12. Modifique o controlador (CDOR) de modo a implementar a nova operação. Para o

efeito, deverá obter as equações Booleanas de cada sinal de controlo, i.e., RW_RO,

RW_TR, OP(2), OP(1), OP(0), utilizando o método de minimização de Karnaugh.

Apresente o logigrama do novo controlador e implemente o novo controlador em

VHDL (modificando o ficheiro controlador.vhd).

Sinal RW_R0:

Expressão=

Sinal RW_TR:

Expressão:

Sinal Op(2):

Expressão=

Sinal Op(1):

Expressão=

FIGURA 13-TABELA DE VERDADE IMPLEMENTAÇÃO DO NOVO R0

FIGURA 14-MAPA KARNAUGH R0

FIGURA 16-MAPA KARNAUGH TR

FIGURA 17-MAPA KARNAUGH OP2

FIGURA 15-MAPA KARNAUGH OP1

9

Sinal Op(0):

Expressão=

13. Modifique o funcionamento do contador de modo a parar a contagem sempre que

chegar ao valor correspondente à primeira instrução NOP. Para o efeito, é preciso

modificar o ficheiro lab4_circuito.vhd (sem nenhuma modificação nos ficheiros

cntr_div16.vhd ou cntr_ff.vhd).

De forma a fazer com que o contador parasse a contagem no 6 (o primeiro NOP aparece no

número 7), removeu-se o fio correspondente à saída ct15 do contador e ligou-se a uma porta

NAND. Às entradas da porta NAND ligou-se os três bits de menor peso do sinal CNTR_dout.

Recorreu-se à utilização de uma porta NAND pois removemos, no VHDL (em anexo no final do

relatório), o sinal cntr_15.

14. Faça a simulação completa do circuito modificado (usando o testbench fornecido

no ficheiro tb_lab4_circuito.vhd) e observe o resultado obtido. Apresente o

resultado da simulação no relatório, incluindo todos os sinais (e na mesma ordem

apresentada no diagrama temporal).

Após se ter realizado todas as alterações, no VHDL, para que o novo algoritmo fosse

implementado, procedeu-se à simulação do circuito obtendo-se assim o diagrama abaixo

representado. Após a análise detalhada do diagrama temporal, reparou-se que as operações

realizadas eram o pretendido e que estas cessavam o seu funcionamento aquando o contador

atingisse o valor 7.

FIGURA 19-MAPA KARNAUGH

OP0

FIGURA 18-CIRCUITO CONTROLADOR ALTERADO

FIGURA 20-SIMULAÇÃO LAB4 CIRCUITO

10

3. IMPLEMENTAÇÃO DO CIRCUITO Após concluído o ficheiro VHDL e efetuadas todas as simulações necessárias criou-se um ficheiro

‘.bit’, o qual foi implementado na placa de prototipagem. Foi introduzido nos switch’s o valor correspondente

ao valor inicial do sensor ‘1011’ e de seguida premiu-se o botão de pressão do sinal INIT o que efetuou o

RESET ao contador iniciando-se assim a contagem. Por fim comparou-se os valores obtidos no display da

placa de prototipagem com os valores obtidos na simulação final do ficheiro tb_lab4_circuito.vhd.

4. CONCLUSÃO Este trabalho laboratorial permitiu-nos voltar a entrar em contacto com a plataforma de trabalho do

ISE da Xilinx e com as placas de prototipagem Basys2.

O objetivo final desta atividade laboratorial era o desenvolvimento de um circuito de computação cuja

função fosse a de realizar o ajuste da inclinação de um painel solar fotovoltaico.

Partindo do logigrama do circuito de computação analisámos detalhadamente o funcionamento de

cada um dos seus componentes bem como as funções de cada um deles com vista a compreender como

cada um deles contribui para o cálculo do algoritmo pretendido.

Ao longo da preparação do trabalho foi-nos requisitado para modificar o funcionamento de certos

componentes tais como, ALU, Contador, e Controlador e para tal tivemos que alterar os ficheiros VHDL,

através da plataforma Xilinx, de cada um destes componentes. Após cada modificação recorreu-se a

simulações para verificar se estes componentes estavam a funcionar conforme o pretendido.

As modificações realizadas ao longo do laboratório foram sendo cada vez mais complexas e no final

obtivemos um algoritmo bastante complexo. Este algoritmo exigiu uma alteração no funcionamento do

controlador para que as operações a realizar fossem as pretendidas. Foi necessário também, uma alteração

no funcionamento do contador para que este parasse a contagem e consequentemente a realização das

operações, assim que recebesse uma instrução NOP equivalente ao valor 7 em binário

Este trabalho permitiu a interiorização dos conceitos teóricos bem com perceber como estes podem

ser aplicadas em situações do quotidiano. Requisitou uma grande dedicação da nossa parte pois o Xilinx é

uma ferramenta complexa exige grande concentração para evitar a ocorrência de erros.

FIGURA 21-PLACA PROTOTIPAGEM

11

Códigos:

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

12

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 op1_Y_tmp, op1_tmp, op0_tmp, q_tmp, arit_out :

std_logic_vector(7 downto 0);

signal lop0, lop1, lop2, lop3, logic_out : std_logic_vector(7

downto 0);

signal s : std_logic_vector(1 downto 0);

begin

--xor

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

op1_Y_tmp <= op1_tmp xor Y;

-- and

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

q_tmp <= op1_Y_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 (logic operation 0)

lop0 <= X nand Y;

-- nor (logic operation 1)

lop1 <= X nor Y;

-- multiplicação por 2 (logic operation 2)

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

--divisão por 2 (logic operation 3)

lop3 <= X(7) & X(7 downto 1);

-- mux 4:1

s <= op(1) & op(0);

with s select

logic_out <= lop0 when "00",

13

lop1 when "01",

lop2 when "10",

lop3 when others;

-- mux 2:1 at the end

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

end Behavioral;

CONTROLADOR:

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

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

-- 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;

14


entity controlador is

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

-- Internal signs

signal A, B, C, D, E, F, G, H, K, J : std_logic;

begin

--RW_R0

A <= (not I(3)) and (not I(2)) and I(0);

B <= (not I(3)) and I(2) and (not I(1));

C <= (not I(3)) and I(2) and (not I(0));

RW_R0 <= A or B or C;

--RW_TR

RW_TR <= (not I(3)) and (not I(2)) and (not I(0));

--OP2

D <= (not I(2)) and (not I(1)) and (not I(0));

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

F <= I(2) and I(0);

OP(2) <= D or E or F;

--OP1

G <= (not I(1)) and (not I(0));

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

OP(1) <= I(2) or G or H;

--op0

K <= (not I(1)) and I(0);

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

OP(0) <= K OR J;

end Behavioral;

LAB 4 CIRCUITO

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

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

-- Company:

-- Engineer:

--

15

-- 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)

);

16

END COMPONENT;

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;

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

17

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 Stop_count_6, A : 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;

-- 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

);

18

---- COUNTER DIV16 ----

-- counter reset

CNTR_rst <= (not Init);

-- PARAGEM NO 6

Stop_count_6 <= NOT (CNTR_dout(1) and CNTR_dout(2) and

CNTR_dout(0));

-- counter enable

CNTR_en <= Insert or Init or Stop_count_6;

-- 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,

q_out => CNTR_dout

);

-- output: INST_OUT

Inst_out <= CNTR_dout;

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

CDOR: controlador PORT MAP(

I => CNTR_dout,

RW_R0 => CDOR_rw_r0,

RW_TR => CDOR_rw_tr,

OP => CDOR_op

);

end Behavioral;

Laboratório 4 RELATÓRIO - Instituto Superior Técnico...

Documents

Transcript of Laboratório 4 RELATÓRIO - Instituto Superior Técnico...