Mudanças entre as edições de "ELD129003-Engtelecom (Diário) - Prof. Marcos Moecke"
(→ATUAL) |
|||
(2 revisões intermediárias pelo mesmo usuário não estão sendo mostradas) | |||
Linha 636: | Linha 636: | ||
[[Restringir a frequencia máxima de clock no Quartus II]] | [[Restringir a frequencia máxima de clock no Quartus II]] | ||
− | + | ||
;Encontro 12 (2 abr.): | ;Encontro 12 (2 abr.): | ||
Instruções do tipo '''LOOP''': LOOP incondicional, '''FOR-LOOP''', '''WHILE-LOOP''', '''NEXT''', '''EXIT''' | Instruções do tipo '''LOOP''': LOOP incondicional, '''FOR-LOOP''', '''WHILE-LOOP''', '''NEXT''', '''EXIT''' | ||
Linha 746: | Linha 746: | ||
{{fig|5.16|Simulação do counting_zeros| SIM_CZ.png| 800 px | }} | {{fig|5.16|Simulação do counting_zeros| SIM_CZ.png| 800 px | }} | ||
+ | *Ver pag. 161 a 164 de <ref name="PEDRONI2010b"/> | ||
+ | |||
+ | ====ATUAL==== | ||
+ | ;Encontro 13 (5 abr.) | ||
+ | * Carry-Ripple Adder (FOR-LOOP) (Ex 6.4) - apenas analisar. | ||
+ | :* Um somador do tipo carry ripple utiliza o bloco básico '''full adder''' para construir somadores de qualquer número de bits. Os bits carry são adicionados aos blocos posteriores, produzindo um hardware combinário. | ||
+ | :* O full adder é baseado nas funções. | ||
+ | ::<math> s_k = a_k \oplus b_k \oplus c_k </math> | ||
+ | ::<math> c_{k+1} = a_k . b_k + a_k . c_k + b_k . c_k </math> | ||
+ | :: onde <math> c_{k+1} </math> é o '''carry out''', <math> c_{k} </math> é o '''carry in''' | ||
+ | |||
+ | Esse somador pode ser implementado tanto com código sequencial como com código concorrente. Note que no primeiro caso o bit de '''carry''' se definido como '''variable''' pode ser reaproveitado. No segundo caso é necessário criar um vetor completo para conectar os '''carry_out''' de um estágio ao '''carry_in''' do próximo. | ||
+ | |||
+ | <syntaxhighlight lang=vhdl> | ||
+ | library ieee; | ||
+ | use ieee.std_logic_1164.all; | ||
+ | |||
+ | entity carry_ripple_adder is | ||
+ | generic (N : integer := 3); | ||
+ | port ( | ||
+ | a, b : std_logic_vector (N-1 downto 0); | ||
+ | cin : std_logic; | ||
+ | s : out std_logic_vector (N-1 downto 0); | ||
+ | cout : out std_logic | ||
+ | ); | ||
+ | end entity; | ||
+ | |||
+ | architecture estrutural_sequencial_v1 of carry_ripple_adder is | ||
+ | begin | ||
+ | -- Uso de um codigo sequencial para geracao de um circuito combinacional | ||
+ | process (a, b, cin) is | ||
+ | variable c : std_logic; | ||
+ | begin | ||
+ | c := cin; | ||
+ | for i in 0 to N-1 loop | ||
+ | s(i) <= a(i) xor b(i) xor c; | ||
+ | c := (a(i) and b(i)) or (a(i) and c) or (b(i) and c); | ||
+ | end loop; | ||
+ | cout <= c; | ||
+ | end process; | ||
+ | end architecture; | ||
+ | |||
+ | architecture estrutural_concorrente_v1 of carry_ripple_adder is | ||
+ | signal c : std_logic_vector(N downto 0); | ||
+ | begin | ||
+ | -- Uso de um codigo concorrente para geracao de um circuito combinacional | ||
+ | c(0) <= cin; | ||
+ | l1: for i in 0 to N-1 generate | ||
+ | s(i) <= a(i) xor b(i) xor c(i); | ||
+ | c(i+1) <= (a(i) and b(i)) or (a(i) and c(i)) or (b(i) and c(i)); | ||
+ | end generate; | ||
+ | cout <= c(N); | ||
+ | end architecture; | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | {{fig|5.1|RTL do carry_ripple_adder de 3 bits | RTL_carry_ripple_adder3.png| 800 px |}} | ||
+ | |||
+ | *Instrução '''WAIT''': WAIT UNTIL, WAIT FOR (simulação apenas), WAIT ON (não implementada no Quartus II). | ||
+ | |||
+ | <syntaxhighlight lang=vhdl> | ||
+ | [rótulo:] WAIT UNTIL <condition>; | ||
+ | [rótulo:] WAIT ON sensitivity_list; | ||
+ | [rótulo:] WAIT FOR time_expression; | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | :Recomenda-se utilizar a lista de sensibilidade do PROCESS e a instrução IF no lugar do WAIT. | ||
+ | :Algumas instruções de '''WAIT''' serão utilizadas na criação de '''TestBench''' em VHDL para a simulação com o '''MODELSIM'''. | ||
+ | |||
+ | * Projetar um contador em BCD entre 0 e 99 ('''countBCD_DU.vhd'''), com entrada de clock, reset e saidas unidade(0 a 9) e dezena (0 a 9). Projete o contador para parar em qualquer valor de DU onde D é a dezena e U é a unidade. | ||
+ | |||
+ | :* versão 1 - contagem crescente. | ||
+ | {{fig|5.2|RTL do contador BCD 00 a 99 | RTL_countBCD00-99.png| 800 px |}} | ||
+ | {{fig|5.3|Simulação do contador BCD 00 a 99 | MODELSIM_countBCD00-99.png| 800 px |}} | ||
+ | |||
+ | ;DESAFIO: | ||
+ | Implementar um contador BCD de 00 a 99, com parada em qualquer valor MAX_DU. Onde se D = 5, U = 9, implica em contar de 000 até 59 e ficar parado neste valor. A atingir o valor final MAX_DU, uma saída adicional OPA deve ser ativada. | ||
+ | *Versão 1: O contador crescente deve usar a proposta de contagem separada de 0 a 9 da Unidade, Dezena (feito em aula), com parada em MAX_DU. | ||
+ | *Versão 2: O contador crescente deve fazer a contagem em binário, e incrementar 6 nos bits da unidade sempre que passar de 9(1001) para 10 (1010), com parada em MAX_DU. | ||
+ | *Versão 3: O contador decrescente deve usar a proposta de contagem separada de 0 a 9 da Unidade, Dezena (feito em aula), com início em MAX_DU e parada em 00. | ||
+ | |||
+ | <!-- | ||
+ | * Projetar um divisor de clock que dado um clock de entrada de f Hz, produza na saída um sinal de clock de f/N onde N é um número inteiro ('''div_clk_N''') | ||
+ | |||
+ | *Projetar um conversor de BCD para SSD - display de sete segmentos ('''BCD2SSD.vhd'''). O circuito deve ter uma entrada que permite escolher se o display é do tipo anodo comum ou catodo comum. | ||
− | |||
{{collapse bottom}} | {{collapse bottom}} | ||
Edição das 12h02min de 5 de abril de 2024
Registro on-line das aulas
Unidade 1 - Aula inicial, Introdução a disciplina
- 1 ENCONTRO
Unidade 1 - Aula inicial, Introdução a disciplina |
---|
|
Unidade REV - PRIMEIRO CONTATO COM VHDL
- 3 ENCONTROS
Unidade REV - PRIMEIRO CONTATO COM VHDL | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
library library_name;
use library_name.package_name.all;
entity entity_name is
[generic (
cons_name1: const_type const_value;
cons_name2: const_type const_value;
...
cons_nameN: const_type const_value);]
[port (
signal_name1: mode signal_type;
signal_name2: mode signal_type;
...
signal_nameN: mode signal_type);]
[declarative_part]
[begin
statement_part]
end [entity] [entity_name];
architecture arch_name of entity_name is
[declarative_part]
begin
statement_part
end [architecture] [arch_name];
Para ilustrar essas instruções utilizaremos o exemplo de um Mux4x1. Um multiplexador digital de N entradas e 1 saída, frequentemente abreviado como MUX N:1, é um circuito digital muito utilizado para rotear sinais digitais. Ele desempenha a função de selecionar uma das entradas para ser encaminhada para a saída com base em um sinal de seleção (ou controle).
Dada a função booleana do MUX4:1 é simples para descreve-lo em VHDL utilizando apenas operadores lógicos. entity mux4x1 is
port
(
-- Input ports
X: in bit_vector (3 downto 0);
Sel : in bit_vector (1 downto 0);
-- Output ports
Y : out bit
);
end entity;
-- Implementação com lógica pura
architecture v_logica_pura of mux4x1 is
begin
Y <= (X(0) and (not Sel(1)) and (not Sel(0))) or
...
end architecture;
No entanto, o MUX4:1 também pode ser descrito utilizando a instrução WHEN-ELSE <optional_label>: <target> <=
<value> when <condition> else
<value> when <condition> else
...
<value> else
<value>;
Warning (13012): Latch ... has unsafe behavior
No caso do MUX4:1 ele poderia ser descrito como: -- Implementação com WHEN ELSE
architecture v_WHEN_ELSE of mux4x1 is
begin
Y <= X(0) when Sel = "00" else
X(1) when Sel = "01" else
X(2) when Sel = "10" else
X(3);
end architecture;
Outra forma de descrever o MUX4:1 seria utilizando a instrução WITH-SELECT <optional_label>: with <expression> select
<target> <=
<value> when <choices>,
<value> when <choices>,
...
<value> when others;
Error (10313): VHDL Case Statement error ...: Case Statement choices must cover all possible values of expression
-- Implementação com WITH SELECT
architecture v_WITH_SELECT of mux4x1 is
begin
with Sel select
Y <= X(0) when "00", -- note o uso da ,
X(1) when "01",
X(2) when "10",
X(3) when others; -- note o uso de others, para todos os demais valores.
-- Não pode ser substituido por "11" mesmo que o signal seja bit_vector.
end architecture;
CONFIGURATION <configuration_name> OF <entity_name> IS
FOR <architecture_name> END FOR;
END CONFIGURATION;
-- Design Unit que associa a architecture com a entity
CONFIGURATION cfg_ifsc OF mux4x1 IS
FOR v_logica_pura END FOR;
-- FOR v_WHEN_ELSE END FOR;
-- FOR v_WITH_SELECT END FOR;
END CONFIGURATION;
Figura 2.1 - Código RTL do mux4x1 v_logica_pura Figura 2.2 - Código RTL do mux4x1 v_WHEN_ELSE Figura 2.3 - Código RTL do mux4x1 v_WITH_SELECT
|
Unidade 2 - Dispositivos Lógicos Programáveis
- 3 ENCONTROS
Unidade 2 - Dispositivos Lógicos Programáveis | ||
---|---|---|
Unidade 3 - Circuitos sequenciais (Implementação com HDL)
|