SISTEMAS DIGITAIS TRABALHO DE LABORATÓRIO IV CIRCUITO DE PROCESSAMENTO DE DADOS RELATÓRIO

Transcrição

1 TRABALHO DE LABORATÓRIO IV CIRCUITO DE PROCESSAMENTO DE DADOS RELATÓRIO Identificação dos Alunos: Nome: Diogo Morgado Número: Nome: Valter Piedade Número: Turno de Laboratório: SD4517L05 Grupo: 77 Sala do Laboratório: LSD1 Hora: 12h30 14h00 Nome do Docente: Aleksandar Ilic

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

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

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

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 0 1 0, 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 = digito menos significativo = 0 K0 = 0 K1 : 84195/4 = 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 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 5

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

7 Pergunta 9: R0 S*2 p P = K0 + 1 = 0+1 = 1 R0 2S Instrução ALU Operação Descrição Resultado Parcial I1 X<<1 (SLA) R0 R0<<1 R0 2S Tabela 1 Processo para realizar a operação R0 2S. RW_R0 RW_TR OP(2) OP(1) OP(0) 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. Operação RW_R0 RW_TR OP(2) OP(1) OP(0) ALU Operação OP X + Y OP X<<1 Tabela 3 Tabela de controlo que realiza as operações OP1 e OP2. 7

8 Pergunta 11: R0 (3S) 2p +1 3S 2 p = (K0 mod 2) + 1 = = 1 R0 (3S 2)+1 3S 2 I(3:0) RW_R0 RW_TR OP(2) OP(1) OP(0) ALU Operação Descrição Resultado Parcial X<<1 (SLA) TR R0<<1 TR 2S X + Y (ADD) R0 TR+1 R0 3S X TR R0 TR 3S X<<1 (SLA) R0 TR<<1 R0 3S* X + 1 (INC) R0 R0+1 R0 3S* X>>1 (SRA) R0 R0>>1 R0 (3S 2) X Y (SUB) R0 R0-TR R0 (3S 2)+1 3S X X X - NOP X X X - NOP X X X - NOP X X X - NOP X X X - NOP X X X - NOP X X X - NOP X X X - NOP X X X - NOP Tabela 4 Tabela de controlo com as operações necessárias para modificar a função realizada para Pergunta 12: R0 (3S 2)+1 3S. 2 Figura 8 Mapa de Karnaugh do sinal de controlo RW_R0. Figura 9 - Mapa de Karnaugh do sinal de controlo RW_TR. Figura 10 - Mapa de Karnaugh do sinal de controlo OP(2). Figura 11 - Mapa de Karnaugh do sinal de controlo OP(1). 8 Figura 12 - Mapa de Karnaugh do sinal de controlo OP(0).

9 RW_R0 I3 (I2I0 + I1 I0 + I2I0 RW_TR I3 I2 I1 ; OP(2) I2 I1 I0 + I0(I2 + I1 OP(1) I1 I0 + I3 I2 + I1I0; OP(0) I1 I0 + I2I1. Expressões simplificadas a partir dos mapas de Karnaugh de cada um dos sinais de controlo. 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. 9

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

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

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 12

13 Dependencies: Revision: Revision File Created Additional Comments: 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 postimplementation 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; BEGIN Inputs signal X : std_logic_vector(7 downto 0) := " "; signal Y : std_logic_vector(7 downto 0) := " "; signal op : std_logic_vector(2 downto 0 Outputs signal D_out : std_logic_vector(7 downto 0 Instantiate the Unit Under Test (UUT) uut: alu PORT MAP ( X => X, Y => Y, op => op, D_out => D_out Stimulus process 13

14 END; 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; 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: Revision 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 controlador is 14

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; SISTEMAS DIGITAIS 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 and2_ro <= not1 and I(0 and3_ro <= not2 and I(0 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; 15

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: Revision 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) END COMPONENT; COMPONENT alu PORT( 16

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; SISTEMAS DIGITAIS 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; 17

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

19 I => CNTR_dout, RW_R0 => CDOR_rw_r0, RW_TR => CDOR_rw_tr, OP => CDOR_op end Behavioral; 19