DLP29006-Engtelecom(2015-1) - Prof. Marcos Moecke

Registro on-line das aulas

Unidade 1

Aula 1 (5 fev)

• Apresentação da disciplina

1. Dispositivos lógicos programáveis.
2. Bases da linguagem VHDL.
3. Tipos de dados, libraries, conversão de tipos, operadores, atributos.
4. Código VHDL concorrente e sequencial.
5. Projeto hierárquico.
6. Simulação e Testbench
7. Maquina de estado finita (FSM).
8. Projeto Final de circuitos lógicos.
9. Avaliações.

• Introdução aos dispositivos lógicos programáveis:

• Conceito, tipos de PLDs
• SPLD: PAL, PLA e GAL

Ver pag. 413 a 418 de

Aula 2 (6 fev)

• Introdução aos dispositivos lógicos programáveis:

• CPLDs e FPGAs
• Fabricantes de DLPs
• Vizualização no Chip Planner de um projeto.

Ver pag. 419 a 424 de

Aula 3 (11 fev)

• Introdução aos dispositivos lógicos programáveis:

• Arquitetura de FPGAs (Xilinx e Altera): CLB, LAB, RAM, DSP, Clock, PLL, I/O
• Vizualização no Chip Planner de um projeto.

Ver pag. 424 a 431 de

Unidade 2

Aula 4 (12 fev)

• Introdução ao VHDL.

• Exemplo de programação de um full adder. Utilize os arquivos .qar enviados (V1 - estrutural. V2 - comportamental) para analisar os circuitos obtidos e realizar as simulações funcional e temporal.

Ver pag. 3 a 8 de

Aula 5 (13 fev)

• Introdução ao VHDL.

• Estrutura do código VHDL
• Libraries, Entity, Architecture

Aula 6 (19 fev)

• Introdução ao VHDL.

• Estrutura do código VHDL
• Exercicios 2.2 (VHDL e QSIM)
• Exemplo de programação de um flip-flop
• Exercicios 2.3 (VHDL e QSIM)

Ver pag. 3 a 8 de

Aula 7 (20 fev)

• Introdução ao VHDL.

• Libraries, Entity, Architechture, Generic.

Ver pag. 11 a 18 de

Aula 8 (25 fev)

• Introdução ao VHDL.

• Exemplo de um circuito somador
• Exemplo de FF-D

Ver pag. 19 a 21 de

Unidade 3

Aula 9 (26 fev)

• Tipos de Dados em VHDL.

• Exemplo de um circuito somador com registrador
• Exemplo de decodificador de endereço genérico

Ver pag. 22 a 27 de

Aula 10 (27 fev)

• Tipos de Dados em VHDL.

• Objetos de VHDL: CONSTANT, SIGNAL, VARIABLE, FILE.
• Palavra chave OTHERS
• Bibliotecas padrão.

• Não use as bibliotecas não padrão (std_logic_arith, std_logic_unsigned, std_logic_signed)

• Tipos de dados: BIT, BIT_VECTOR, BOOLEAN, INTEGER, NATURAL, POSITIVE, CHARACTER, STRING, STD_(U)LOGIG, STD_(U)LOGIG_VECTOR, (UN)SIGNED
• Classificação dos tipos de dados.
• Exemplo 3.1 Buffer Tri-state
• Exemplo 3.3 Multiplicador

Ver pag. 31 a 54 de

Aula 11 (5 mar)

• Tipos de Dados em VHDL.

• Tipos Array definidos pelo usuário: 1D, 1D x 1D, 2D, 1D x 1D x 1D, 3D.

Ver pag. 62 a 79 de

Aula 12 (6 mar)

• Operadores em VHDL.

• Operadores predefinidos: Atribuição, Logicos, Arithméticos, Comparação, Deslocamento, Concatenação, "Matching".
• Sobrecarga de operadores

Ver pag. 91 a 98 de

Aula 13 (11 mar)

• Atributos em VHDL.

• Atributos predefinidos: tipo escalar e enumerados; tipo array; de sinal;
• Exemplo 4.1 (Simulação funcional)
• Atributos definidos pelo usuário;
• Atributos de síntese: Enum_encoding, chip_pin, keep.
• Exemplo: Delay line (Síntese e Simulação temporal sem o com o atributo keep)

Ver pag. 99 a 109 de

Aula 14 (12 mar)

• Atributos em VHDL.

• Atributos de síntese: preserve, noprune.
• Exemplo: Redundant Register
• Group e Alias
• Exercício 4.17: Discussão de possibilidades de implementação

Ver pag. 109 a 119 de

Unidade 4

Aula 15 (13 mar)

• Código Concorrente.

• WHEN, SELECT, GENERATE;
• Exemplo 5.1 + 5.2 mux: com 4 tipos de arquiteturas (com operadores, com WHEN, com SELECT, com IF),
• Uso de CONFIGURATION para selecionar um entre várias arquiteturas.

CONFIGURATION which_mux OF mux IS
   FOR with_OPERATOR END FOR;
--   FOR with_WHEN END FOR;
--   FOR with_SELECT END FOR;
--   FOR with_IF END FOR;
END CONFIGURATION;

• Exemplo 5.3 ALU: modificação do opcodes: "0011" -> a NAND b, "0100" -> "a OR b, "1111" => a * b. É necessário mudar a ENTITY, dobrando o número de bits da saída devido a multiplicação, e adaptar o código para a nova quantidade de bits.

Ver pag. 121 a 129 de

Aula 16 (19 mar)

• Código Concorrente.

Aula 17 (20 mar)

• Código Concorrente.

Aula 18 (25 mar)

• Código Concorrente.

• Implementação de circuitos arithméticos com operadores.

LEMBRETE

• Para "+" ou "-": O tamanho do resultado é igual ao número de bits do maior operando.

r[7..0] = a[7..0] + b[4..0]; a -> 8 bits; b -> 5 bits então r -> 8 bits.

• Para "*": O tamanho do resultado é igual a soma do número de bits dos dois operandos.

r[12..0] = a[7..0] * b[4..0]; a -> 8 bits; b -> 5 bits então r -> 8+5 bits.

• Para "/": O tamanho do resultado é igual ao número de bits do numerador.

r[5..0] = a[5..0] * b[8..0]; a -> 6 bits; b -> 9 bits então r -> 6 bits.

• Aula de exercicios:

5.4 - Generic Parity Generator;

5.6 - Generic Binary-to-Gray Converter;

5.7 - Hamming Weight with GENERATE;

5.8 - Binary Sorter with GENERATE;

5.10/11 - Arithmetic Circuit with INTEGER/STD_LOGIC;

5.15/16/17/18 - (Un)signed Multiplier/Divider;

5.19 - Frequency Multiplier.

Unidade 5

Aula 20 (16 Mai)

• Código Sequencial.

• 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
• Instrução IF

• Exemplos: DFFs with Reset and Clear (Variação Ex 6.1), Basic Counter (Ex. 6.2), Shift Register (Ex. 6.3)

• Instrução WAIT: WAIT UNTIL, WAIT FOR (simulação apenas), WAIT ON (não implementada no Quartus II).

Recomenda-se utilizar a lista de sensibilidade do PROCESS e a instrução IF no lugar do WAIT.

• Ver pag. 161 a 160 de

Unidade 6

Aula 21 (8 abr)

• Projeto a nível de Sistema.

• O PACKAGE e PACKAGE BODY: onde declarar e como usar.
• O COMPONENT: declaração (cópia da ENTITY) e instanciação.

• Associação dos nomes das portas aos sinais. PORT -> PORT MAP:

• Ver pag. 201 a 205 de

Aula 22 (9 abr)

• Projeto a nível de Sistema.

• O COMPONENT:

• Criação de compomentes redimensionáveis. GENERIC -> GENERIC MAP
• Mapeamento por posição e nominal.
• Métodos de declaração de COMPONENT.

• Exemplo: Registrador Circular Ex. 8.2

• Ver pag. 205 a 208 de

Aula 23 (10 abr)

• Avaliação das Unidades 1 a 4.

Aula 24 (16 abr)

• Projeto a nível de Sistema.

• Criação de COMPONENT redimensionáveis. GENERIC -> GENERIC MAP

• Exemplo: Porta E com N entradas.
• Exemplo: Detector de Paridade Ex. 8.3

• Instanciação de COMPONENT com GENERATE.

• Exemplo: Registrador de deslocamento M x N Ex. 8.4

• Ver pag. 208 a 213 de

Aula 25 (17 abr)

• Projeto a nível de Sistema.

• Uso da instrução CONFIGURATION.

• Ligação direta: ARCHITECTURE-ENTITY.
• Ligação da instanciação dos componentes: COMPONENT-ENTITY(ARCHITECTURE).

• O BLOCK.
• A instrução ASSERT condicional e incondicional
• A FUNCTION: declaração, uso, mapeamento posicional x nominal, PURE x IMPURE.

• Ver pag. 213 a 226 de )
• Ver exercício proposto na AE5.

Aula 26 (22 abr)

• Projeto a nível de Sistema.

• Uso de FUNCTION e ASSERT.

• Exemplo: Declaração em ARCHITECTURE Ex.9.1
• Exemplo: Declaração em PACKAGE Ex. 9.2
• Exemplo: Declaração em ENTITY Ex. 9.3

• Ver pag. 226 a 230 de

Aula 27 (23 abr)

• Projeto a nível de Sistema.

• Uso de PROCEDURE.

• Exemplo: min_max Ex.9.4
• Exercícios: 9.1 a 9.4, 9.6 a 9.9

• Ver pag. 230 a 239 de

Aula 28 (24 abr)

• Projeto a nível de Sistema.

• Projeto de um conversor de hexadecimal para display de 7 segmentos.

Ver EL7 - Projetar Conversor de hexadecimal para 7 segmentos

Aula 29 e 30 (30 abr e 6 mai)

• Projeto a nível de Sistema.

• Projeto de um relógio com saída em display de 7 segmentos de HH:MM:SS.

Ver EL8 - Projetar um relógio de 24 horas

Unidade 7

Aula 31 (7 mai)

Simulação com o ModelSim

• Seguir o tutorial [1]
• Para usar o ModelSim 10.1d na CLOUD-IFSC abra um terminal e digite:

/opt/altera/13.0sp1/modelsim_ase/bin/vsim

• Para usar o ModelSim 10.1d no LabProg abra um terminal e digite:

/opt/altera/13.0/quartus/modelsim_ase/linux/vsim

Complementos

• Ler também Using ModelSim to Simulate Logic Circuits in VHDL Designs
• Ver também Performing a Functional Simulation with the ModelSim-Altera Software, e Performing a Timing Simulation with the ModelSim-Altera Software.
• Seguindo o tutorial da ALTERA para o MODELSIM - exemplo de um somador serial de 8 bits (projeto hierárquico com componentes: shift register, full adder e FSM)

Aula 32-33 (8 e 14 mai)

Simulação com o ModelSim X Qsim

• Implementar o relógio da AE8 e realizar a simulação no QSIM e ModelSim.
• Executar Modelsim a partir do Quartus II. Simulação usando comandos gráficos.
• Criação de arquivo wave.do (para armazenamento dos sinais e formatos).
• Criação do arquivo tb_relógio.do (para compilar, simular, definir os estimulos e executar 48 hr de simulação).
• Análise dos graficos temporais e correção do hardware implementado.

Aula 34 (15 mai)

• Tipos de testbench funcional e temporal:

• Gráfico -> DUT -> Gráfico (funcional RTL). Usar project.vhd + tp_project.vwf (QSIM) ou project.vhd + tb_project.do (ModelSim)
• Gráfico -> DUT -> Gráfico (funcional pós-síntese). Usar project.vho + tb_project.do (ModelSim)

• Geração de estimulos para testbench:

• VHDL -> DUT -> Gráfico (funcional RTL). Usar project.vhd + tp_project.vwf (QSIM) ou project.vhd + tb_project.vhd (ModelSim)
• VHDL -> DUT -> Gráfico (funcional pós-síntese). Usar project.vho + tb_project.vhd (ModelSim)
• VHDL -> DUT -> Gráfico (temporal). Usar project.vho + tb_project.vhd + project.sdo (ModelSim)

• Teste automático da saída usando o sinal esperado e tempo de propagação.

• VHDL -> DUT -> VHDL (funcional RTL). Usar project.vhd + tp_project.vwf (QSIM) ou project.vhd + tb_project.vhd (ModelSim)
• VHDL -> DUT -> VHDL (funcional pós-síntese). Usar project.vho + tb_project.vhd (ModelSim)
• VHDL -> DUT -> VHDL (temporal). Usar project.vho + tb_project.vhd + project.sdo (ModelSim)

• Exemplo Multiplexador Registrado

Ver pag. 241 a 245 e 251 a 264 de

Complementos

• Ver também site que gera um template de testbench a partir do código vhdl da top_entity (DUT): http://www.doulos.com/knowhow/perl/testbench_creation/
• Ver este tutorial da ALTERA que ensina como gerar um template de testbench usando o Quartus II.

Aula 35 (20 mai)

• Simulação do RelógioHHMMSS da AE6 no ModelSim tanto funcional como temporal

• teste com geração automática de estimulo (clk) com VHDL -> DUT -> Gráfico.
• teste com análise automática das saídas VHDL -> DUT -> VHDL.

Unidade 8

Aula 36 (21 mai)

Máquinas de Estados Finitos (FSM)

• Diagrama de transições, Representação em Hardware
• Template VHDL para FSM, exemplo 11.1 "vending_machine"
• Simulação do Ex11.1 no Modelsim com testbench de geração de estímulos em VHDL.

Ver pag 277 a 287 de

Aula 37 (22 mai)

Dúvida sobre o Exercício 6.9 (debouncer)

Máquinas de Estados Finitos (FSM)

• Simulação funcional e temporal do Ex11.3 no Modelsim com testbench de geração de estímulos em VHDL.
• Criando projeto no ModelSim para facilitar a simulação.

Ver pag 287 de

Aula 38 (28 mai)

Dúvida sobre os Exercícios da Unidade 5 e 6

• Termino do testbench do Projeto do relógio HH:MM:SS.

Aula 39 (29 mai) (2h30)

Avaliação A2

Aula 40 (4 jun)

Máquinas de Estados Finitos (FSM)

• Tipos de codificação dos estados: Sequential, Gray, Johnson, One-hot, "User-defined encoding".

--------------------------------------------------------
TYPE state IS (A, B, C, D, E, F);
SIGNAL pr_state, nx_state: state;
--------------------------------------------------------
ATTRIBUTE enum_encoding: STRING;
ATTRIBUTE enum_encoding OF state: TYPE IS "sequential";
-- A="000", B="001", C="010", D="011", E="100", F="101"
--------------------------------------------------------
ATTRIBUTE enum_encoding: STRING;
ATTRIBUTE enum_encoding OF state: TYPE IS "gray";
-- A="000", B="001", C="011", D="010", E="110", F="111"
--------------------------------------------------------
ATTRIBUTE enum_encoding: STRING;
ATTRIBUTE enum_encoding OF state: TYPE IS "johnson";
-- A="000", B="100", C="110", D="111", E="011", F="001"
--------------------------------------------------------
ATTRIBUTE enum_encoding: STRING;
ATTRIBUTE enum_encoding OF state: TYPE IS "one-hot";
-- A="000001", B="000010", C="000100", D="001000", E="010000", F="100000"
--------------------------------------------------------
ATTRIBUTE enum_encoding: STRING;
ATTRIBUTE enum_encoding OF state: TYPE IS "111 100 110 011 000 101";
-- A="111", B="100", C="110", D="011", E="000", F="101"
--------------------------------------------------------

• Detalhes de uso do Quartus II para definir o tipo de codificação dos estados.

Se não for usado o ATTRIBUTE enum_encoding, é possível definir diretamente no quartus o tipo de enumeração a ser usado na maquina de estado.

Para selecionar o tipo [Assignments > Settings > Analysis & Synthesis Settings > More Settings > State Machine Processing > [Escolha a opção]].

• Resolvendo o problema do Bypass de estados com Flags e estados de Wait.
• Simulação funcional do Ex11.4 e 11.5 no Modelsim com testbench de geração de estímulos em VHDL.

Ver pag 289 a 297 de

Unidade 9

Aula 41 a 50 (11/06 a 3/06)

Projeto, Simulação e Implementação de um sistema.

• Os alunos foram divididos em equipes de 2 alunos, e cada equipe projetou, simulou e implementou um sistema.

• EQUIPE 1: Matuzalem.
• EQUIPE 2: Tiago.
• EQUIPE 3: Karoline e Ana.
• EQUIPE 4: Guilherme e Mathias.

• Ao final do projeto, além do código VHDL e das simulações e teste utilizando um kit FPGA, cada equipe de apresentar um relatório com a descrição detalhada do projeto e os resultados obtidos.

Avaliações

• Avaliação A1 - Unidade 2, 3 e 4
• Avaliação A2 - Unidade 5 e 6
• Entrega dos diversos trabalhos ao longo do semestre AE1 a AE7.
• Projeto Final. Tem peso equivalente a duas avaliações, sendo avaliado nos quesitos: 1) Implementação do Sistema, 2) Documentação, 3) Avaliação Global do aluno no projeto.

Atividades extra

ATIVIDADES EXTRA

AE1 - Estudo do tipo de programação dos FPGA (prazo 20/02/2015)
Fazer uma pesquisa sobre as formas como os PLDs são programados. Fusíveis, antifusíseis, memória PROM, EPROM, EEPROM, Flash, SRAM, etc. Formar equipes de até 2 alunos e apresentar um resumo em 2 a 3 páginas A4.

AE2 - Estudo do Quartus II e Dispositivos FPGA (prazo 27/02/2015)

Utilize no Quartus II o arquivo adders.qar para realizar os seguintes procedimentos: P0 - Selecione a família de FPGA Cyclone e selecione o dispositivo EP1C3T100A8 P1 - Selecione como Top-Level Entity o arquivo adder_4bits.vhd e compile esse código [Processing > Start Compilation]. Anote o número de Elementos Lógicos (ou ALUTs) utilizados [Compilation Report > Flow Summary]. Verifique qual é o maior tempo de propagação entre as entradas a,b e saida sum [Compilation Report > TimeQuest ... > Datasheet Report > Propagation Delay]. Verifique o código RTL gerado [Tools > Netlist Viewers > RTL Viewer] Verifique como o circuito foi sintetizado abrindo o [Chip Planner], e após dar um zoom no Elemento lógico (ou ALUT) utilizado verifique o hardware que foi utilizado com o [Resource Property Editor] Faça a simulação funcional utilizando o arquivo tb_adder_4bits.vwf no QSIM, e verifique se as somas estão corretas. P2 - Selecione como Top-Level Entity o arquivo adder_ripple_4bits.bdf e compile esse código [Processing > Start Compilation]. Repita os passos do procedimento P1. P3 - Troque a familia do FPGA para Stratix III e selecione o dispositivo EP3SE50F484C2 e repita os procedimento P1 e P2 acima. P4 - Análise os resultados obtidos e chegue as suas conclusões. Escreva os resultados em um artigo resumido de 1 a 2 páginas. Exemplos ilustrativos de utilização do elemento lógico/ALUT Adder de 4 bits em EP1C3T100A8 Adder de 4 bits em EP3SE50F484C2 Riple Adder de 4bits em EP3SE50F484C2

AE3 - Uso de operadores e tipos de dados (Prazo de entrega 23/03/2015)

Para o exercício 4.15 escreva um código VHDL e faça a simulação temporal. Para o exercício 4.17 escreva um código VHDL e analise o número de elementos lógicos necessários. Compare com os outros estudantes e analise das diferenças. Para facilitar os testes e a troca de informações entre as equipes, a ENTITY deverá ter o seguinte formato: entity bin2bcd is port ( num_bin : in std_logic_vector(9 downto 0); C_bcd : out std_logic_vector(3 downto 0); D_bcd : out std_logic_vector(3 downto 0); U_bcd : out std_logic_vector(3 downto 0)); end entity;

AE4 - Uso de código concorrente - ALU multiplicadora (Prazo de entrega 01/04/2015)

A Unidade de Lógica e Aritmética deve ter as seguintes funções: Unidade Lógica Instrução Operação opcode Complemento de A y = not A 0000 Complemento de B y = not B 0001 And y = A and B 0010 Nand y = A nand B 0011 Or y = A or B 0100 Nor y = A nor B 0101 Xor y = A xor B 0110 Xnor y = A xnor B 0111 Unidade Aritmética Instrução Operação opcode Transfere A y = A 1000 Transfere B y = B 1001 Incrementa A y = A + 1 1010 Decrementa A y = A - 1 1011 Soma A e B y = A + B 1100 Subtrai B de A y = A - B 1101 Multiplica A e B y = A * B 1110 Dobra o valor A y = A * 2 1111 As operações aritméticas devem considerar apenas números positivos. Indique a validade do resultado com o bit valid. Válido => valid = '1', Inválido => valid = '0'. A ENTITY deverá ter a seguinte interface: ENTITY alu IS GENERIC (N: INTEGER := 4); --word bits PORT ( a, b: IN STD_LOGIC_VECTOR(N-1 DOWNTO 0); opcode: IN STD_LOGIC_VECTOR(3 DOWNTO 0); valid: out STD_LOGIC; y: OUT STD_LOGIC_VECTOR(2*N-1 DOWNTO 0)); END ENTITY; Proponha uma ARCHITECTURE que implemente a ALU (Dica: utilize o tipo de dado tipo integer). Anote o número de Elementos Lógicos (ou ALUTs) utilizados [Compilation Report > Flow Summary]. Verifique qual é o maior tempo de propagação entre as entradas a,b e saida sum [Compilation Report > TimeQuest ... > Datasheet Report > Propagation Delay]. Verifique o código RTL gerado [Tools > Netlist Viewers > RTL Viewer] Faça a simulação funcional e temporal no QSIM, e verifique se as operações estão corretas. Análise os resultados obtidos considerando as entradas com 4 bits e também com 8 bits.

AE5 - Circuitos Genéricos com código estrutural (Prazo de entrega 04/05/2015)

Projete os três circuitos a seguir, utilizando: i) código estrutural; ii) componentes genéricos conforme indicado: Somador do tipo carry-ripple de N bits (componente: Full Adder). Contador Assíncrono de módulo $2^{N}$ (componente: Divisor por 2). Contador Síncronos de módulo $2^{N}$ (componente: Módulo mostrado na figura 8.9 de ). Teste cada componente separadamente e utilize-o para criar os circuito acima. Implemente cada circuito acima utilizando 3 bits e também 32 bits. Verifique o código RTL gerado [Tools > Netlist Viewers > RTL Viewer]. Anote o número de Elementos Lógicos (ou ALUTs) utilizados [Compilation Report > Flow Summary]. Verifique qual é o maior tempo de propagação entre as entradas de cada circuito e as saídas [Compilation Report > TimeQuest ... > Datasheet Report > Propagation Delay]. Faça a simulação funcional e temporal no QSIM, e verifique se os circuitos estão funcionando corretamente. Análise os resultados obtidos. De um título coerente ao artigo e faça um resumo e introdução que esteja relacionado aos resultados que você deseja analisar. Escreva um relatório na forma de artigo, utilizando preferencialmente o modelo de artigo no padrão ABNT, disponível no ShareLaTeX do IFSC-CLOUD. Faça um resumo e introdução que esteja relacionado aos resultados que você deseja analisar. De um título coerente ao artigo. Seja criativo... Imagens muito grandes deverão ser acrescidas ao artigo na forma de apêndice (preferencialmente use a wiki com um hiperlink no artigo).

AE6 - Testbench completo para FSM do alarme do carro(Prazo de entrega 11/06/2015)
Escrever em vhdl (ou um arquivo .do) para realizar o teste completo da FSM do Ex.11-5 Entregar o QAR do projeto, os arquivos de testbench e a captura da imagem da simulação realizada.

AE7 - Simulação e Teste Final do Relógio HH:MM:SS (Prazo de entrega 17/06/2015)
Implementar o relógio HH:MM:SS em hardware usando o kit DE2-115 (Consulte: Preparando para gravar o circuito lógico no FPGA) Entregar o QAR do projeto, os arquivos de testbench, a captura da imagem da simulação realizada e também a listagem da pinagem utilizada no kit DE2-115.

Projeto Final (Prazo de entrega 06/07/2015)

Implementar o projeto final em hardware usando o kit DE2-115 ou Mercurio IV (Consulte: Preparando para gravar o circuito lógico no FPGA) Entregar o QAR do projeto, os arquivos de testbench, a captura da imagem da simulação realizada e também a listagem da pinagem utilizada no kit DE2-115. Fazer um relatório técnico, descrevendo o sistema implementado, os seus principais blocos, a execução do projeto hierárquico. Além da parte teórica é importante descrever como o sistema foi mapeado para o hardware, indicando a função dos dispositivos na placa (Led, chaves, displays, etc).

ESTUDOS LIVRES (DE DOCUMENTAÇÃO)

EL1 - Estrutura do VHDL

Faça o exercício 2.1 , completando o código VHDL. Idente o código. Procure entender o código inserindo comentários onde julgar importante. Depois de tudo realizado compile e simule o código. Procure obter zero erros na primeira complilação. ---------------------------------------------------- LIBRARY ieee; USE _________________________; ---------------------------------------------------- ENTITY mux IS PORT (___, ___: ___ STD_LOGIC_VECTOR(7 DOWNTO 0); sel: IN ____________________________; ___: OUT STD_LOGIC_VECTOR(__ DOWNTO 0)); END _____; ---------------------------------------------------- ARCHITECTURE example OF _____ IS BEGIN PROCESS (a, b, ____) BEGIN IF (sel="00") THEN x <= "00000000"; ELSIF (__________) THEN x <= a; _____ (sel="10") THEN x <= __; ELSE x <= "___________"; END ___; END __________; END __________; ---------------------------------------------------- </syntaxhighlight>

EL2 - Estudo dos atributos em VDHL

entity atributte_test_array is port( x1, x2, x3, x4, x5, x6: out integer range 0 to 15; x7, x8: out boolean; m12, m44, m47: out bit); end entity; architecture ifsc of atributte_test_array is TYPE matrix IS ARRAY (1 TO 4, 7 DOWNTO 0) OF BIT; SIGNAL test: matrix := (('0', '1', '1', '0', '0', '1', '1', '0'), "01110100", ('1', others => '0'), (4 => '0', others => '1')); begin -------------------------------------------------------------------------- x1 <= matrix'LEFT(1); --result=1 (type of x1 must be INTEGER or eq.) x2 <= matrix'LEFT(2); --result=7 (type of x2 must be INTEGER or eq.) x3 <= matrix'RIGHT(1); --result=4 (type of x3 must be INTEGER or eq.) x4 <= matrix'RIGHT(2); --result=0 (type of x4 must be INTEGER or eq.) x5 <= matrix'LENGTH(1); --result=4 (type of x5 must be INTEGER or eq.) x6 <= matrix'LENGTH(2); --result=8 (type of x6 must be INTEGER or eq.) x7 <= matrix'ASCENDING(1); --result=TRUE (type of x7 must be BOOLEAN) x8 <= matrix'ASCENDING(2); --result=FALSE (type of x8 must be BOOLEAN) m12 <= test(1,2); -- result = '1' - Acess the element of 'test' row(1), columm(2) (type of m11 must be bit) m47 <= test(4,7); -- result = '1' - Acess the element of 'test' row(7), columm(7) (type of m11 must be bit) m44 <= test(4,4); -- result = '0' - Acess the element of 'test' row(4), columm(4) (type of m11 must be bit) -------------------------------------------------------------------------- end architecture;

EL3 - Resolução dos exercícios do Cap 3
Resolva os exercícios da capítulo 3 (1, 2, 9, 11-13, 18-20, 23-30) pag. 81 a 89

EL4 - Resolução dos exercícios do Cap 4
Resolva os exercícios da capítulo 4 (4-11, 13, 15-17 ) pag. 115 a 120

EL5 - Resolução dos exercícios do Cap 5
Resolva os exercícios da capítulo 5 (1, 3, 4, 6-11, 14-19) pag. 144 a 150

EL6 - Projetar Conversor de binário para 7 segmentos

Projetar em VHDL dois conversores de binário para 7 segmentos a) usando código concorrente (SELECT) e b) usando código sequencial (CASE). Considerar a saída do conversor com lógica positiva (ativo = '1'). Simular o circuito com valores de entrada entre 0 = "0000" até 15 = "1111". Para entradas de 0-9 devem ser mostrados os valores decimais no display. Para entradas de 10 a 14 é indiferente o valor a ser mostrado. Para o valor 15 deve ser ativado apenas o segmento g Conferir se as saídas estão corretas para cada uma das entrada. Dica: leia Display de 7 segmentos. ENTITY ssd IS PORT ( bin: IN STD_LOGIC_VECTOR(3 DOWNTO 0); ssd: OUT STD_LOGIC_VECTOR(6 DOWNTO 0) ); END ENTITY;

EL7 - Projetar Conversor de hexadecimal para 7 segmentos

Projetar em VHDL conversores de hexadecimal para 7 segmentos, usando: (a) Uma architecture em código concorrente (SELECT) . (b) Uma architecture em código sequencial (CASE). (c) Instanciando uma component usando a entity de (a) ou de (b). (d) Uma function ssd <= hex2ssd_f(hex); (e) Uma procedure hex2ssd_p(hex, ssd); Use como top-entity: ENTITY hex2ssd IS PORT ( hex: IN STD_LOGIC_VECTOR(3 DOWNTO 0); ssd: OUT STD_LOGIC_VECTOR(6 DOWNTO 0) ); END ENTITY; Considere a saída do conversor com lógica negativa (ativo = '0'). Simule todas as 5 opções de circuito usando sempre o mesmo Test Bench, variando os valores da entrada hex entre 0 = "0000" até 15 = "1111". Para entradas de 0 a 9 devem ser mostrados os valores decimais no display. Para entradas de 10 a 15 devem ser mostrados as letras A,b,C,d, E, F. Conferir se as saídas estão corretas para cada uma das entrada. Dica: leia Display de 7 segmentos.

EL8 - Projetar um relógio de 24 horas

Projetar em VHDL um relógio de 24 horas com saida em 6 displays de 7 segmentos. A interface externa do relógio deve ser: entity relogio_HHMMSS is port ( rst : in std_logic; -- Reset assincrono do relogio clk_1seg : in std_logic; -- Sinal de clock com periodo de 1 segundo SS_U, SS_D : out std_logic_vector(6 downto 0); -- Saida ssd de Unidade e Dezena de Segundo MM_U, MM_D : out std_logic_vector(6 downto 0); -- Saida ssd de Unidade e Dezena de Minuto HH_U, HH_D : out std_logic_vector(6 downto 0) -- Saida ssd de Unidade e Dezena de Hora ); end entity; O projeto deverá utilizar o componente (ou função (ou procedure)) do circuito he2ssd projetado no EL7.

EL9 - Resolução dos exercícios do Cap 6, 8 e 9
Resolva os exercícios da capítulo 6 (1-7, 9*, 10-11, 12*, 13*, 14) pag. 172 a 176. Resolva os exercícios da capítulo 8 (1-7, 9*) pag. 219 a 220. Resolva os exercícios da capítulo 9 (1-3, 6-9) pag. 238 a 239.

Referências Bibliográficas:

Curso de Engenharia de Telecomunicações