Mudanças entre as edições de "ELD129003-Engtelecom (Diário) - Prof. Marcos Moecke"

De MediaWiki do Campus São José
Ir para navegação Ir para pesquisar
Linha 820: Linha 820:
 
{{fig|5.3|Simulação do contador BCD 00 a 99 | MODELSIM_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 000 a 99 crescente, 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 AQUI deve ser ativada.
 +
*Versão 1: O contador deve usar a proposta de contagem separada de 0 a 9 da Unidade, Dezena (feito em aula), mas precisa incluir a parada.
 +
*Versão 2: O contador deve fazer a contagem em binário, e incrementar 6 nos bits da unidade sempre que passar de 9(1001) para 10 (1010).
 +
 +
 +
<!--
 
* 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 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''')
  

Edição das 11h57min 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
Encontro 1 (16 fev)
  • A página da UC contém os materiais que não alteram entre semestre.
  • Relação com as outras UCs do Eixo Sistemas Computacionais (Marrom). Ver grafo do curriculo
  • ELD129002 - ELETRÔNICA DIGITAL I (ELD1): Sistema de numeração e códigos. Lógica booleana. Circuitos combinacionais. Circuitos aritméticos. Linguagem de descrição de hardware. Implementação e teste de circuitos digitais. Projeto de circuitos lógicos.
  • ELD129003 - ELETRÔNICA DIGITAL II (ELD2): Dispositivos lógicos programáveis. Circuitos sequenciais. Metodologia síncrona. Projeto hierárquico e parametrizado. Máquinas de estados finita. Register Transfer Methodology. Teste de circuitos digitais. Implementação em FPGA. Introdução a Linguagem de Descrição de Hardware.
  • AOC129004 - ARQUITETURA E ORGANIZAÇÃO DE COMPUTADORES (AOC): Introdução à Arquitetura Computadores. Linguagem Assembly. Linguagem de Máquina. Programação Assembly. Modos de Endereçamento. Processo de compilação e carga de um programa. Introdução à Organização de Computadores. Organização Monociclo e Multiciclo. Pipeline. Memória e Sistema de E/S.
  • MIC129007 - MICROCONTROLADORES (MIC): Introdução a Microcontroladores e Aplicações. Arquitetura de um microcontrolador. Pilha e Subrotinas. Interrupção. Contadores e Temporizadores. Interface com Periféricos. Programação em alto nível (ex.: C, C++ e RUST) para Microcontroladores: Mapeamento de tipos e estruturas de alto nível para sistemas com recursos limitados. Projeto de hardware e firmware com microcontroladores.
  • STE129008 - STE - SISTEMAS EMBARCADOS (STE): Conceitos em Sistemas Embarcados. Metodologia de Desenvolvimento de Sistemas Embarcados. Sistemas Operacionais para Sistemas Embarcados. Ferramentas de desenvolvimento e depuração. Barramentos e dispositivos de acesso a redes. Desenvolvimento de Projeto.
  • Nesta página está o Registro diário dos encontros e avaliações.
  • A entrega de atividades e avaliações será através da plataforma Moodle. A inscrição dos alunos é automática a partir do SIGAA.
  • Para a comunicação entre professor-aluno, além dos avisos no SIGAA, utilizaremos o chat institucional. A princípio todos os alunos já estão previamente cadastrados pelo seu email institucional. Confiram enviando uma mensagem de apresentação.
  • Utilizaremos durante as aulas algumas ferramentas computacionas como o site do Falstad para entender circuitos digitais e fazer simulações básicas.
  • Também utilizaremos os softwares Quartus Light e ModelSim instalados nas maquinas do laboratório para praticar a parte de programação de hardware (descrição de hardware). Esses softwares também podem ser usados através da Nuvem do IFSC..
LER PARA O PRÓXIMO ENCONTRO
  • Revisão dos conceitos sobre circuitos combinacionais vistos em CIL/ELD1
  • Para alunos que não cursaram ELD1 (não conhecem VHDL), irei fornecer uma sequência de estudos para conhecer melhor as instruções concorrentes do VHDL.
  • Ler Introdução a linguagem de descrição de hardware (DHL)

Unidade REV - PRIMEIRO CONTATO COM VHDL

  • 3 ENCONTROS
Unidade REV - PRIMEIRO CONTATO COM VHDL
Encontro 2 (20 fev)
  • Estrutura do código VHDL
  • Declaração das bibliotecas e pacotes LIBRARY / PACKAGE
 library library_name;
 use library_name.package_name.all;
  • ENTITY
 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
 architecture arch_name of entity_name is
   [declarative_part]
 begin
   statement_part
 end [architecture] [arch_name];


PARA O PRÓXIMO ENCONTRO
  • Para os alunos que são da matriz curricular 1290 (PPC 2023).
  • Para conhecer um pouco mais da linguagem VHDL, ler VHDL ou VHDL.en. A maioria dessas instruções serão tratadas posteriormente.
Encontro 3 (23 fev)
  • Descrição do harware utilizando código VHDL no Quartus.
  • Rever a IDE do Quartus
  • Realizar análise e síntese.
  • Obter Diagrama RTL e Technology Map do circuito
  • Realizar simulação funcional com ModelSim
  • Conhecer a IDE do ModelSim
  • Seguir o procedimento descrito em Uso do ambiente EDA - QUARTUS Prime para programação em VHDL
Encontro 4 (27 fev)
Como arquivar um projeto
Conhecer instruções WHEN_ELSE, WITH_SELECT, CONFIGURATION

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

Mux2x1

A tabela verdade que descreve um MUX2:1 é mostrada abaixo:

X1 X0 Sel Y
0 0 0 0
0 0 1 0
0 1 0 1
0 1 1 0
1 0 0 0
1 0 1 1
1 1 0 1
1 1 1 1

O MUX2:1 também pode ser representado de forma resumida por:

X1 X0 Sel Y
- X0 0 X0
X1 - 1 X1

Onde o X0 e X1 na entrada podem assumir os valores 0 ou 1, e o simbolo "-" corresponde ao don't care (em VDHL)

A função booleana que descreve a operação de um MUX 2:1 pode ser representada da seguinte forma:


Onde Y é a saída; Sel é o sinal de seleção; X0 e X1 são as entradas.

Mux4x1

O MUX4:1 pode ser representado de forma resumida pela tabela verdade:

Entradas Seleção Saída
X3 X2 X1 X0 Sel1 Sel0 Y
- - - X0 0 0 X0
- - X1 - 0 1 X1
- X2 - - 1 0 X2
X3 - - - 1 1 X3

A função booleana que descreve a operação de um MUX 4:1 pode ser representada da seguinte forma:

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>;
  • Importante: O último ELSE sem condição para cobrir todos os demais valores para evitar a criação de LATCHES.
Warning (13012): Latch ... has unsafe behavior
  • No QuartusII existe um template pronto para ser utilizado em: [Edit > Insert Template > Language templates = VHDL (+) > Constructs (+) > Concurrent Statemens (+) > Conditional Signal Assignment]

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;
  • Importante: Para cobrir todas as demais possibilidades deve ser utilizado o WHEN OTHERS evitando novamente a criação de LATCHES, ou erros de análise.
Error (10313): VHDL Case Statement error ...: Case Statement choices must cover all possible values of expression
  • No QuartusII existe um template pronto para ser utilizado em: [Edit > Insert Template > Language templates = VHDL (+) > Constructs (+) > Concurrent Statemens (+) > Selected Signal Assignment]. Mas ATENÇÃO, faltam as virgulas após cada escolha.
-- 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;
  • Note que para associar uma entre várias arquiteturas com a sua ENTITY pode-se utilizar a instrução CONFIGURATION. No exemplo abaixo a ARCHITECTURE que está descomentada é a que será associada a ENTITY mux4x1.
  • Caso não se use a instrução CONFIGURATION, a última ARCHITECTURE será associada a ENTITY.
  • Apesar de apenas uma das ARCHITECTUREs ser associada, todas elas devem estar sintaticamente corretas, pois passarão pelo processo de ANÁLISE E SINTESE.
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;
  • Faça a análise e sintese do mux4x1, associando a architecture v_logica_pura, depois v_WITH_SELECT, depois v_WHEN e por último v_IF_ELSE.
  • Note a diferença entre os RTL Viewer obtidos para cada architecture.

Figura 2.1 - Código RTL do mux4x1 v_logica_pura
RTL mux4x1v1.png
Fonte: Elaborado pelo autor.

Figura 2.2 - Código RTL do mux4x1 v_WHEN_ELSE
RTL mux4x1v2.png
Fonte: Elaborado pelo autor.

Figura 2.3 - Código RTL do mux4x1 v_WITH_SELECT
RTL mux4x1v3.png
Fonte: Elaborado pelo autor.
OBS: Register Transfer-Level (RTL) é uma abstração na qual o circuito é descrito em termos de fluxo de sinais entre os registradores presentes no hardware e as operações combinacionais realizadas com esses dados.
PARA O PRÓXIMO ENCONTRO
  • Realize a simulação das 3 arquiteturas do MUX4:1 no Modelsim
  • Crie um arquivo tb_mux4x1_v1.do que repita a simulação da arquitetura v1
  • Crie um arquivo tb_mux4x1_v2.do que repita a simulação da arquitetura v2
  • Crie um arquivo tb_mux4x1_v3.do que repita a simulação da arquitetura v1
  • Inclua todos os arquivos .do no projeto do Quartus e salve o arquivo QAR
  • Ver essa página Simulação Funcional usando o ModelSim


Unidade 2 - Dispositivos Lógicos Programáveis

  • 3 ENCONTROS
Unidade 2 - Dispositivos Lógicos Programáveis
Encontro 5 (1 mar)
  • Introdução aos dispositivos lógicos programáveis:
  • Conceito, tipos de PLDs
  • SPLD:
Exemplos de PLDs

Figura 2.1 - Exemplo de PAL
PedroniFig4 4a.png
Fonte: http://www.vhdl.us/book/Pedroni_VHDL_3E_Chapter4.pdf.

Figura 2.2 - Exemplo de PLA
PedroniFig4 4b.png
Fonte: http://www.vhdl.us/book/Pedroni_VHDL_3E_Chapter4.pdf.

Figura 2.3 - Macrobloco do PLD EP300 da ALTERA
Ep310 macrocell.jpg
Fonte: https://www.altera.com/solutions/technology/system-design/articles/_2013/in-the-beginning.html.

Figura 2.4 - Macrocélula dos PLDs Clássicos EP600, EP900, EP1800 da ALTERA (1999)
Macrocell EP900.png
Fonte: https://www.altera.com/content/dam/altera-www/global/en_US/pdfs/literature/ds/archives/classic.pdf.

Figura 2.5 - Architetura do PLD EP1800 da ALTERA
Ep1800 block diagram.jpg
Fonte: https://www.altera.com/solutions/technology/system-design/articles/_2013/in-the-beginning.html.

Figura 2.6 - Architetura do PLD EP1800 da ALTERA
Ep1800 block diagram2.jpg
Fonte: https://www.altera.com/content/dam/altera-www/global/en_US/pdfs/literature/ds/archives/classic.pdf.

Figura 2.7 - Pinagem e tipos de encapsulamento do PLD EP1800 da ALTERA
PackagePinOut EP1810.png
Fonte: https://www.altera.com/content/dam/altera-www/global/en_US/pdfs/literature/ds/archives/classic.pdf.

Figura 2.8 - Architetura do CPLD MAX 5000 da ALTERA
Max 5000 architecture.jpg
Fonte: https://www.altera.com/solutions/technology/system-design/articles/_2013/in-the-beginning.html.
PARA O PRÓXIMO ENCONTRO
Encontro 6 (5 mar)
  • Arquitetura de FPGAs (Xilinx e Altera): CLB, LAB, LUT, Flip_flop D, RAM, DSP, Clock, PLL, DLL, I/O
FONTE: FPGA Architecture - ALTERA
Exemplos de FPGA

Figura 2.9 - Arquitetura de um FPGA
Architecture FPGAs.png
Fonte: https://www.intel.com/content/www/us/en/docs/programmable/683176/18-1/fpga-overview-opencl-standard.html.

Figura 2.10 - Diagrama simplificado da ALM de um FPGA Intel/Altera
ALM LUT FPGAs.png
Fonte: https://www.intel.com/content/www/us/en/content-details/771003/fpga-architecture-8-input-lut-legacy-white-paper.html.

Figura 2.11 - Arquitetura interna de uma LUT
LUT FPGAs.png
Fonte: FPGA Architecture - ALTERA.

Figura 2.12 - Configuração de uma LUT
LUT FPGAs Config.png
Fonte: https://www.allaboutcircuits.com/technical-articles/purpose-and-internal-functionality-of-fpga-look-up-tables/.

Figura 2.13 - Arquitetura do Cyclone® V Intel/Altera
CycloneV FPGAs.jpg
Fonte: https://www.intel.com.br/content/www/br/pt/products/details/fpga/cyclone/v/article.html.

Figura 2.14 - Leiaute de um FPGA Xilinx genérico
Leiaute2 FPGAs.jpg
Fonte: https://www.sciencedirect.com/science/article/pii/B9780750678667500032.

Figura 2.15 - Roteamento de sinal em um FPGA
Roteamento FPGAs.jpg
Fonte: https://www.sciencedirect.com/science/article/pii/B9780750678667500032.

Figura 2.16 - Tecnologias usadas na configuração de FPGAs
FPGA programming.png
Fonte: https://www.sciencedirect.com/topics/computer-science/one-time-programmable.
Ver também SRAM, EEPROM, What Is Flash Memory
PARA O PRÓXIMO ENCONTRO
  • Leia a assista a alguns dos vídeos sobre a historia e processo de produção dos chips.
Encontro 7 (8 mar)
  • System on Chip

Figura 2.17 - Altera - Visão geral do dispositivo Arria V SX e ST
ArriaV SX ST Chip.png
Fonte: https://br.mouser.com/datasheet/2/612/av_51001-1623623.pdf.

Figura 2.18 - Altera - Agilex 7 SoCs HPS Digrama de Blocos
Agilex7SoC Blocos.png
Fonte: https://static6.arrow.com/aropdfconversion/b568cfe009abfed6a28eff56700189883d7fc179/ag-overview-683458-666707.pdf.
PARA O PRÓXIMO ENCONTRO
  • Ver preços de DLPs em
  • Fabricantes de DLPs/FPGAs e familias de DLPs atuais.

Unidade 3 - Circuitos sequenciais (Implementação com HDL)

  • 8 ENCONTROS
Unidade 3 - Circuitos sequenciais (Implementação com HDL)
Encontro 8 (12 mar)
  • Flip-Flop e circuitos sequenciais.
  • Diferenças entre código concorrente e sequencial <=> circuitos combinacional e sequencial
  • Diferenças entre os objetos SIGNAL e VARIABLE
  • Tipos de elementos de memória: Latch x Flip-flop
  • Latch D
  • Flip-flop tipo D com reset assíncrono e com reset (clear) síncrono
  • Seção de código sequencial PROCESS: lista de sensibilidade
[rótulo:] PROCESS [(lista_de_sensibilidade)] [IS]
             [parte_declarativa]
         BEGIN
             afirmação_sequencial;
             afirmação_sequencial;
             ...
         END PROCESS [rótulo];
  • Instrução IF
[rótulo:] IF condição THEN
             afirmação_sequencial;
             afirmação_sequencial;
             ...
         ELSIF condição THEN
             afirmação_sequencial;
             afirmação_sequencial;
             ...
         ELSE
             afirmação_sequencial;
             afirmação_sequencial;
             ...
         END IF [rótulo];
  • Exemplos:
  • DFFs com Reset Assincrono e Reset Sincrono, com Enable, com Preset (Variação Ex 6.1).
--Flip Flop tipo D com reset assincrono, sensivel a borda de subida.
process (clock,reset)
begin
   if (reset = '1') then
      q <= '0';
-- elsif (clock'event and clock = '1') then or
   elsif (rising_edge(clock)) then
      q <= d;
   end if;
end process;

Figura 5.1 - RTL de Flip-flop D de borda de subida, com reset assíncrono
FF D RST.png
Fonte: Elaborado pelo autor.
--Flip Flop tipo D com preset assincrono e sinal de enable, sensivel a borda de descida.
process (clock, preset)
begin
   if (preset = '1') then
      q <= '1';
   elsif (falling_edge(clock)) then
      if (enable = '1') then
         q <= d;
      end if;
   end if;
end process;

Figura 5.2 - RTL de Flip-flop D de borda de descida, com preset assíncrono e enable
FF D PRST.png
Fonte: Elaborado pelo autor.
Encontro 9 (15 mar)
  • Comparar com Latch (sem clk'event).
--Latch tipo D com reset assincrono.
process (enable, reset, d)
begin
   if (reset = '1') then
      q <= '0';
   elsif (enable='1')) then
      q <= d;
   end if;
end process;

Figura 5.3 - RTL de Latch D de com reset assíncrono e enable ativo alto
LATCH D RST.png
Fonte: Elaborado pelo autor.
  • Na figura abaixo, note que o Latch é implementado utilizando a LUT do elemento lógico do FPGA, enquanto que o Flip-flop utiliza o componente já disponível neste elemento lógico.
  • Evite os latches no projeto

Figura 5.4 - Comparação do Technology Map de um Latch_D (esquerda) com FF_D (direita)
FF D LATCH D.png
Fonte: Elaborado pelo autor.
-- Flip Flop tipo D com reset síncrono sensível a borda de subida. 
-- Modifique a descrição para que o reset_ass seja assíncrono e reset_sinc seja síncrono.
-- Note que a função rising_edge(clock) é equivalente a (clock'event and clock'last_value = '0' and clock = '1'))

process (clock, reset)
begin
   if (reset = '1') then
      q <= '0';
   elsif (clock'event and clock'last_value = '0' and clock = '1')) then
      q <= d;
   end if;
end process;

Figura 5.5 - RTL do Flip-flop D com reset assíncrono e reset síncrono
FF D RST SINC ASINC.png
Fonte: Elaborado pelo autor.
  • Exercício: Implemente um registrador com N FF_D no lugar de um único FF_D.

Figura 5.6 - RTL do Registrador (de 4 bits) com reset assíncrono
REG RST.png
Fonte: Elaborado pelo autor.

Figura 5.7 - Techonogy Map do Registrador (de 4 bits) com reset assíncrono
TM REG RST.png
Fonte: Elaborado pelo autor.
  • Faça a simulação funcional do DFFs e do Latch
Encontro 10 (22 mar)
  • Implementar um registrador com N FF_D usando a instrução FOR GENERATE.
-- Instrução concorrente FOR GENERATE.
-- Note que neste caso o '''label''' é obrigatório

label: FOR identificador IN faixa GENERATE
   [Parte_Declarativa
BEGIN]
   Instruções_concorrentes
   ...
END GENERATE [label];
  • Implementar um registrador de deslocamento de N bits.
entity shift_reg is
	generic ( N : natural := 4);
	port 	(
		clock, reset : in  std_LOGIC ;
		d_in:  in std_LOGIC;
		q_out : out std_LOGIC);
end entity;

architecture ifsc_v1 of shift_reg is
	signal d: std_logic_vector(N-1 downto 0);
	signal q: std_logic_vector(N-1 downto 0);
begin
   ...
end architecture;

Figura 5.8 - Technology Map de Shift Register
Shift reg TM.png
Fonte: Elaborado pelo autor.

Figura 5.9 - Simulação de Shift Register
800 px
Fonte: Elaborado pelo autor.
  • Implementar um contador crescente 0-N (baseado no Ex.6.2), com N = 2^Mbits-1 (1 3 7 15)
  • Com overflow no valor máximo
entity conta_0_N is
	generic (MAX : natural := 15);
	port 	(clock, reset: in  std_logic; q : out integer range 0  to MAX);
end entity;

architecture ifsc_v1 of conta_0_N is

begin
	process (clock,reset)
		variable count : integer range 0  to MAX;
	begin
		if (reset = '1') then
			count := 0;
		elsif (rising_edge(clock)) then
			count := count + 1;
		end if;
		q <= count;
	end process;
end architecture;

Figura 5.10 - RTL de contador crescente
Counter 0 M RTL.png
Fonte: Elaborado pelo autor.
Encontro 11 (26 mar)
  • Implementar um contador crescente 0 até N, com N ≠ 2^Mbits (5, 10)
  • Com overflow no valor máximo

Figura 5.11 - RTL contador crescente 0 a 5
Counter 0 5 RTL.png
Fonte: Elaborado pelo autor.

Figura 5.12 - Simulação do contador crescente 0 a 5
Counter 0 5 SIM.png
Fonte: Elaborado pelo autor.
  • Com parada no valor máximo
  • Implementar um contador decrescente N até 0, com N ≠ 2^Mbits (5, 10)
  • Com underflow no valor mínimo

Figura 5.13 - Simulação do contador decrescente 5 a 0
Counter 5 0 SIM.png
Fonte: Elaborado pelo autor.
  • Com parada no valor mínimo

Figura 5.14 - Simulação do contador decrescente 5 a 0 com parada
Counter 5 0 SIM stop.png
Fonte: Elaborado pelo autor.


DESAFIO
Implementar um contador bidirecional entre MIN e MAX. Uma entrada DIR indica a direção da contagem. Considere DIR = 0 (crescente) e DIR = 1 (decrescente).
  • Versão 1: Com underflow no valor mínimo (MIN) e overflow no máximo (MAX).
  • Versão 2: Com parada no valor mínimo (MIN), se decrescente e também no máximo (MAX) se crescente.

Restringir a frequencia máxima de clock no Quartus II

ATUAL

Encontro 12 (2 abr.)

Instruções do tipo LOOP: LOOP incondicional, FOR-LOOP, WHILE-LOOP, NEXT, EXIT

  • Instrução LOOP incondicional:
[rótulo:] LOOP
             afirmação_sequencial;
             afirmação_sequencial;
             ...
          END LOOP [rótulo];
  • Instrução FOR-LOOP:
[rótulo:] FOR identificador IN faixa LOOP
             afirmação_sequencial;
             afirmação_sequencial;
             ...
          END LOOP [rótulo];
  • Instrução WHILE-LOOP:
[rótulo:] WHILE condição LOOP            -- Executa as "afirmações enquanto a "condição" for verdadeira
             afirmação_sequencial;
             afirmação_sequencial;
             ...
          END LOOP [rótulo];
  • Instrução LOOP com EXIT:
[rótulo:] [FOR identificador IN faixa] LOOP
             afirmação_sequencial;
             EXIT [rótulo] [WHEN condição];    -- Se a "condição" é verdadeira, termina o "LOOP"
             afirmação_sequencial;
             ...
          END LOOP [rótulo];
  • Instrução LOOP com NEXT:
[rótulo:] [FOR identificador IN faixa] LOOP
             afirmação_sequencial;
             NEXT [rótulo] [WHEN condição];    -- Se a "condição" é verdadeira, não executa as linhas até a linha "END LOOP"
                                               -- e incrementa o "identificador".
             afirmação_sequencial;
             ...
          END LOOP [rótulo];
  • Instrução CASE
 [rótulo opcional:] CASE expressão IS
                  WHEN valor =>                             -- valor único
                    afirmação_sequencial;                            
                    afirmação_sequencial;                            
                    ...
                  WHEN valor1 | valor2 | ... | valorN  =>   -- lista de valores
                    afirmação_sequencial;                            
                    afirmação_sequencial;                            
                    ...
                  WHEN valor1 TO valor2 =>                  -- faixa de valores
                    afirmação_sequencial;                            
                    afirmação_sequencial; 
                    ...
                  WHEN OTHERS  =>                          -- para evitar latches
                    afirmação_sequencial;                            
                    afirmação_sequencial; 
                    ...
          END CASE;
Exemplos
  • Leading Zeros (LOOP com EXIT) (Ex 6.5) - Esse circuito deve determinar quantos zeros tem em um vetor de entrada Data antes do primeiro bit '1', começando da esquerda para a direita.
  • Fazer a síntese do circuito; fazer simulação no Modelsim; analisar a forma como o compilador implementou o incrementador.
entity leading_zeros is
	generic (N : natural := 8);
	port
		(	________ : in std_logic_vector(0 to N-1);
			count	: out integer range 0 to N
		);
end entity;

architecture ____ of leading_zeros is

begin
	process (data)
	variable count : integer ____ 0 to N
	begin
		count := 0;
		for i ___ data'range ____
			case data(i) is
				when '0' => count := count + 1;
				when _____ => exit;
			end  ___
		end ____
		zeros <= count;
	end process;
end _______;

Figura 5.15 - Simulação do leading_zeros
SIM LZ.png
Fonte: Elaborado pelo autor.
  • Contador de zeros (LOOP com NEXT ou apenas LOOP) - Esse circuito deve determinar quantos zeros tem em um vetor de entrada Data.
  • Fazer a síntese do circuito; fazer simulação no Modelsim; analisar a forma como o compilador implementou o incrementador.

Figura 5.16 - Simulação do counting_zeros
SIM CZ.png
Fonte: Elaborado pelo autor.


  • Ver pag. 161 a 164 de [1]
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.
onde é o carry out, é 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.

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;

Figura 5.1 - RTL do carry_ripple_adder de 3 bits
RTL carry ripple adder3.png
Fonte: Elaborado pelo autor.
  • Instrução WAIT: WAIT UNTIL, WAIT FOR (simulação apenas), WAIT ON (não implementada no Quartus II).
 [rótulo:] WAIT UNTIL <condition>;
 [rótulo:] WAIT ON sensitivity_list;
 [rótulo:] WAIT FOR time_expression;
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.

Figura 5.2 - RTL do contador BCD 00 a 99
RTL countBCD00-99.png
Fonte: Elaborado pelo autor.

Figura 5.3 - Simulação do contador BCD 00 a 99
MODELSIM countBCD00-99.png
Fonte: Elaborado pelo autor.
DESAFIO

Implementar um contador BCD de 000 a 99 crescente, 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 AQUI deve ser ativada.

  • Versão 1: O contador deve usar a proposta de contagem separada de 0 a 9 da Unidade, Dezena (feito em aula), mas precisa incluir a parada.
  • Versão 2: O contador deve fazer a contagem em binário, e incrementar 6 nos bits da unidade sempre que passar de 9(1001) para 10 (1010).


  1. 1,0 1,1 Erro de citação: Marca <ref> inválida; não foi fornecido texto para as refs chamadas PEDRONI2010b