lab-s4-relatorio

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
1
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.
FIGURA 1-LOGIGRAMA ALU-PARTE LÓGICA
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 2-LOGIGRAMA CTR_FF
2
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
3
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:
FIGURA 4-SIMULAÇÃO LAB 4 CIRCUITO
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.
4
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 010 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= 100012
Cálculo N1:
840704=21017 Resto=2=K1
2+6=810002
FIGURA 5-LOGIGRAMA CONTADOR
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 6-TABELA DE VERDADE DAS OPERAÇÕES DA ALU
5
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:
FIGURA 7-MAPA DE KARNAUGH DE
Y
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.
FIGURA 8-TABELA DE VERDADE DA ALU
MODIFICADA
FIGURA 9-LOGIGRAMA ALU MODIFICADA
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.
6
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 R02S
Assim, a operação a realizar é um shift left aritmético que corresponde a uma multiplicação por 2.
FIGURA 10-TABELA INSTRUÇÕES
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:
FIGURA 11-TABELA SINAIS CONTROLO
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 TRR0+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 R0R0<<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).
FIGURA 12-TABELA OPERAÇÕES 1 E 2
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
7
0+1=1
p=1
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.
FIGURA 13-TABELA DE VERDADE IMPLEMENTAÇÃO DO NOVO R0
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:
Sinal Op(2):
Expressão=
Expressão=
FIGURA 17-MAPA KARNAUGH OP2
FIGURA 14-MAPA KARNAUGH R0
Sinal Op(1):
Expressão=
Sinal RW_TR:
Expressão:
FIGURA 16-MAPA KARNAUGH TR
FIGURA 15-MAPA KARNAUGH OP1
8
Sinal Op(0):
Expressão=
FIGURA 19-MAPA KARNAUGH
OP0
FIGURA 18-CIRCUITO CONTROLADOR ALTERADO
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 20-SIMULAÇÃO LAB4 CIRCUITO
9
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
10
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
11
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",
12
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:
-- 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;
13
--use UNISIM.VComponents.all;
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:
--
14
-- Create Date:
15:51:08 11/05/2015
-- Design Name:
-- Module Name:
lab4_circuit - 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 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)
);
15
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
16
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
);
17
---- 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;
18