VLSI :: TUTORIAL
PROGRAMA DE PÓS-GRADUAÇÃO EM CIÊNCIA DA COMPUTAÇÃO – PPGCC IFCE
Active-HDL Implementação e Simulação em VHDL
MARACANAÚ 2015.2
FAUSTO SAMPAIO
O objetivo deste tutorial é apresentar de forma
simples e objetiva o uso básico da ferramenta
Active-HDL para implementação e simulação de
circuitos digitais descritos em VHDL.
Tutorial: Active-HDL| Fausto Sampaio
1
Sumário Introdução ..................................................................................................................................... 2
Linguagem VHDL ....................................................................................................................... 2
IDE Active-HDL........................................................................................................................... 2
Caso de Estudo .............................................................................................................................. 3
Entidade de projeto .................................................................................................................. 4
Declaração da entidade e corpo da arquitetura ................................................................... 4
Classe de objetos ................................................................................................................... 5
Tipos ...................................................................................................................................... 5
Operadores ............................................................................................................................ 5
Comando “PROCESS” ............................................................................................................ 6
Interagindo com a IDE Active-HDL ................................................................................................ 6
Criando um novo arquivo .......................................................................................................... 8
Compilando o código ................................................................................................................ 9
Simulando o projeto ................................................................................................................ 10
Configurando as entradas para simulação .............................................................................. 11
Resultado da simulação .......................................................................................................... 12
Caso de Estudo 2 ......................................................................................................................... 13
Código do segundo exemplo ................................................................................................... 13
Resultado do segundo exemplo .............................................................................................. 13
Possíveis aplicações ..................................................................................................................... 14
Tutorial: Active-HDL| Fausto Sampaio
2
Introdução
A maior parte deste tutorial baseia-se na obra “VHDL Descrição e Síntese de Circuitos
Digitais” de Roberto d’Amore como referencial teórico e implementação/simulação de alguns
exercícios presentes no livro.
Linguagem VHDL
VHDL ou "VHSIC Hardware Description Language" (Linguagem de descrição de hardware
VHSIC "Very High Speed Integrated Circuits") é uma linguagem usada para facilitar o design
(projeto/concepção) de circuitos digitais em CPLDs, FPGAs e ASICs.
É uma linguagem de descrição de “hardware”, ou seja, uma forma estruturada para a
descrição de circuitos digitais. Essa linguagem permite que o circuito eletrônico seja descrito
com sentenças, tais como em uma linguagem de programação, possibilitando que seja simulado
e sintetizado, isto é, transformado em portas lógicas.
IDE Active-HDL
Active-HDL é uma ferramenta baseada em Windows, permite a criação e simulação de
projetos integrados em FPGA. A mesma também permite desenvolvimento com ambientes
baseados em equipe. A IDE inclui uma HDL completa e um conjunto de ferramentas gráficas para
a rápida implantação e verificação de projetos em FPGA.
Para adquirir a versão estudante da ferramenta, acesse o link abaixo e após um breve
cadastro, um link para o endereço do download da IDE será enviado para seu e-mail cadastrado.
Active-HDL Student Edition - https://www.aldec.com/students/student.php?id=5
Figura 1: Tela inicial do Active-HDL Student Edition
Tutorial: Active-HDL| Fausto Sampaio
3
Caso de Estudo
Como caso de estudo utilizaremos o exemplo do Quadro 6.6.1 ilustrado no livro de
Roberto d’Amore que apresenta um exercício baseado em máquinas de estados.
Na Figura 2, é ilustrado o diagrama de estados de uma máquina com quatro estados que
realiza uma contagem entre os valores “00”, “01”, “11” e “10”, simulando um contador Gray de
2 bits. Para simplificação do circuito, o valor que representa o estado atual corresponde ao valor
das saídas. A máquina inclui, também, uma entrada para inicialização assíncrona denominada
“rst”.
Figura 2: Máquina de quatro estados
A Figura 3 apresenta uma possível descrição para a máquina de estado proposta. O
código contém uma construção do tipo “IF ELSE” que detecta condições: sinal “rst” ativo e
ocorrência de uma borda de subida no sinal de clock. O sinal “rst” ativo leva a máquina para o
estado “00”, e a ocorrência de uma transição entre “0” e “1” no sinal “ck” leva a uma mudança
de estado. O estado futuro é determinado por uma construção “CASE WHEN”, sendo o estado
atual o valor das saídas.
Figura 3: Código do exemplo proposto
Tutorial: Active-HDL| Fausto Sampaio
4
Para entender melhor o código da Figura 3, abordaremos de forma introdutória alguns
elementos que compõem uma descrição em VHDL, tais como entidade de projeto, classes de
objeto, tipos e operadores.
Entidade de projeto Em VHDL, uma entidade de projeto ilustrada na Figura 4, pode representar desde uma
simples porta lógica a um sistema completo, e é composta de duas partes: declaração da
entidade e arquitetura. A declaração da entidade define a interface entre entidade e o ambiente
exterior, como, por exemplo, entradas e saídas de um circuito. A arquitetura contém a
especificação das relações entre as entradas e saídas de uma entidade.
Declaração da entidade e corpo da arquitetura A Figura 5 apresenta a declaração para a entidade do nosso caso de estudo. A declaração
inicia com a palavra reservada “ENTITY” seguida do nome que a identifica. A cláusula “PORT” é
empregada para definir o modo e tipo das portas de entrada e saída da descrição.
O modo de uma porta determina a direção e como os comandos na arquitetura podem
operar com as portas. Existem quatro modos possíveis de uma porta: “IN”, “OUT”, “BUFFER” e
“INOUT”.
Nos modos “IN” e “OUT”, há portas que operam exclusivamente como entrada e saída.
No modo “BUFFER”, a porta opera unicamente no modo saída, diferenciando do modo “OUT”
porque o valor apresentado pode ser referenciado internamente pela arquitetura. Uma porta
do modo “OUT” não pode, por exemplo, controlar um sinal interno da entidade; no caso de uma
porta do tipo “BUFFER”, isso é permitido. O modo “INOUT” caracteriza uma porta bidirecional.
O corpo de uma arquitetura inicia-se com a palavra reservada “ARCHITECTURE” seguida
de um nome identificador e o nome da declaração de entidade associada. As linhas seguintes
podem conter declarações de sinais e constantes, declarações que identificam os componentes
externos utilizados ela arquitetura, bem como a descrição completa de subprogramas que são
utilizados localmente pela arquitetura. Os comandos concorrentes que descrevem a entidade
ficam entre as palavras reservadas “BEGIN” e “END”.
Figura 4: Exemplo de entidade de projeto
Figura 5: Declaração da Entidade do Caso de Estudo
Tutorial: Active-HDL| Fausto Sampaio
5
A Figura 6 apresenta a arquitetura do nosso caso de estudo.
Figura 6:Arquitetura do caso de estudo
Classe de objetos Objetos são elementos que contêm um valor armazenado. Quatro classes de objetos
são definidas em VHDL: “CONSTANT”, “VARIABLE”, “SIGNAL” e “FILE”.
Tipos Objetos de tipos diferentes não é permitida a transferência de valores. Na Figura 7 são
ilustrados os tipos disponíveis pela linguagem VHDL.
Figura 7: Exemplo de tipos pré-definidos no pacote padrão VHDL
Operadores Os operadores definidos são divididos em classes que estabelecem a precedência na
execução das operações. Na Figura 8 são apresentadas, em ordem crescente de precedência, as
classes de operações. Os operadores de mesma classe possuem o mesmo nível de precedência.
Figura 8: Operadores definidos por classe
Tutorial: Active-HDL| Fausto Sampaio
6
Comando “PROCESS” Um processo permite definir um área contendo comandos sequências. A palavra
reservada “PROCESS” identifica o comando conforme o formato apresentado na Figura 9. Um
processo é composto de duas regiões: parte de declaração e a parte de comandos sequenciais;
A primeira região é o local para a declaração de tipos e subtipos, constantes, variáveis,
entre outros. A declaração de sinais não é permitida. A segunda região, após a palavra reservada
“BEGIN”, inicia a área contendo comandos sequenciais que representam o comportamento de
uma parte ou de toda descrição.
A palavra reservada “PROCESS” pode ser antecedida de um rótulo qualquer, e ser
seguida de uma lista de sensibilidade. Essa lista define a quais sinais o conjunto de comandos
contido no processo é sensível. Ou seja, ocorrendo uma mudança no valor de um dos sinais
contidos na lista, o processo será executado. No exemplo deste tutorial o rótulo do processo é
“abc” e a lista de sensibilidade é composta pelos sinais “ck” e “rst”.
Interagindo com a IDE Active-HDL
Depois de adquirida e instalada, abra a IDE Active-HDL Student Edition. Logo após, será
exibida uma janela perguntando se desejamos criar um “Workspace” ou selecionar um
existente. Clique no botão “OK” e digite “Tutorial” para o nome do nosso “Workspace” de
acordo com as ilustrações da Figura 10.
Figura 9: Exemplo de processo
Figura 10: Criando um workspace
Tutorial: Active-HDL| Fausto Sampaio
7
Após ter clicado em “OK” na janela “New Workspace”, podemos criar um projeto com a ajuda
da janela “New Design Wizard”. Para nosso exemplo criaremos nosso primeiro projeto de
acordo com a Figura 11.
Depois de concluir a criação do projeto a tela inicial (ver Figura 12) do Active-HDL será exibida.
Figura 12: Criando um projeto
Figura 13: Tela Inicial
5
4
6
1
2 3
Figura 11:Criando um projeto
Tutorial: Active-HDL| Fausto Sampaio
8
1. Aba de MENU;
2. Paleta padrão da IDE;
3. Simulação;
4. Navegação do Projeto;
5. Área de trabalho;
6. Console.
Criando um novo arquivo Para criar um novo arquivo, temos que clicar no item “Add new File” na área de
navegação do projeto. Com isso será exibida uma janela pedindo para informarmos o tipo de
arquivo e o nome do mesmo. Para o nosso exemplo informaremos “maq_est1” como nome do
arquivo e por final pressione o botão “OK”. (ver Figura 14).
Figura 14: Adicionando um novo arquivo no projeto
Tutorial: Active-HDL| Fausto Sampaio
9
No arquivo recentemente criado digitaremos o código do nosso caso de estudo que
está escrito logo abaixo, e depois temos que salvá-lo (Ctrl+S) .
Obs: Comentários iniciam-se com “--“ (dois traços).
Compilando o código Quando um arquivos teve alguma modificação e ainda não foi compilado, observa-se ao
lado do nome do arquivo um poro de interrogação, sinalizando que o mesmo não foi compilado
(ver Figura 14). Para compilar o código basta ativar a tecla de atalho “F11” ou clicando com o
botão direito do mouse no arquivo alvo e depois clicar no item “Compilar”. Caso o código tenha
algum erro ou warning os mesmos serão exibidos na aba Console.
ENTITY maq_est1 IS
PORT (ck : IN BIT; -- relogio borda subida
rst : IN BIT; -- rst=1, q=00
q : BUFFER BIT_VECTOR (1 DOWNTO 0)); -- saida codigo Gray
END maq_est1;
ARCHITECTURE teste OF maq_est1 IS
BEGIN
abc: PROCESS (ck, rst)
BEGIN
IF rst = '1' THEN -- estado inicial
q <= "00";
ELSIF (ck'EVENT and ck ='1') THEN -- ciclo de estados
CASE q IS
WHEN "00" => q <= "01";
WHEN "01" => q <= "11";
WHEN "11" => q <= "10";
WHEN "10" => q <= "00";
END CASE;
END IF;
END PROCESS abc;
END teste;
Figura 15: Arquivo não compilado
Tutorial: Active-HDL| Fausto Sampaio
10
Simulando o projeto Depois do código ter sido salvo e compilado, o próximo passo será a simulação. Para
deixarmos a IDE no modo de simulação temos que acionar a aba de menu e clicar no item
“Initialize Simulation” de acordo com a Figura 15.
Quando a IDE entra no modo de simulação a área de navegação do projeto (Designed
Browser) é modificada de acordo com a Figura 16.
Figura 16: inicializando a simulação
Figura 17: Entradas para simulação
Tutorial: Active-HDL| Fausto Sampaio
11
Como nosso exemplo necessita de um sinal de clock, podemos abrir uma janela de
simulação chamada WaveForm, no qual trabalha com sinais no formato de ondas.
Para adicionar um WaveForm é necessário está no modo de simulação e clicar com o
botão direito do mouse no nome da entidade do arquivo a ser simulado. (ver Figura 17).
Depois de adicionar o WaveForm, a área de trabalho da IDE será modificada de acordo
coma Figura 18.
Configurando as entradas para simulação
Para darmos início à simulação do projeto, temos que configurar as estradas/saídas do
projeto. Com a tela do WaveForm ativada, acione a combinação de teclas “Ctrl+A” para
selecionar todas os objetos do projeto e em seguida clique com o botão direito do mouse nos
objetos selecionados e depois clique com o esquerda na opção “Simulators”. Após isso será
exibida uma janela de configurações do objetos. Configure os objetos conforme a Figura 19. Para
confirmar a configuração para cada objeto temos que clicar em “Apply”. No nosso exemplo será
necessário apenas configurar um sinal de clock para o objeto (variável) “ck” (10MHz).
Figura 18: Adicionando o WaveForm
Figura 19: WaveForm
Tutorial: Active-HDL| Fausto Sampaio
12
Figura 20: Configurando o sinal de clock
Finalmente para executar a simulação, basta ficar clicando no botão destacado na Figura
20 ou ficar pressionando F5, que a IDE executará um teste apresentando o comprimentos de
onda com períodos de 100ns, esse tempo pode ser modificado conforme imagem abaixo.
Resultado da simulação A Figura 21 exibi o resultado da simulação do caso de estudo proposto inicialmente
com sinal de clock de 10Mhz e dois pulsos no sinal de “rst”.
Figura 21: Configurando simulação
Figura 22: Resultado do exemplo proposto
Tutorial: Active-HDL| Fausto Sampaio
13
Observou-se que a simulação executou de acordo com a descrição em VHDL do exemplo
inicial. No processo, primeiramente verifica se “rst” tem valor “1”, se verdadeiro a saída “q”
recebe “00”, fato verificado no tempo de 800ns, pois o próximo estado de “q” deveria ser “11”.
Caso “rst” for “0”, a cada subida de borda do clock “ck” haverá uma transição de estado.
Caso de Estudo 2 Como nova proposta de estudo modificaremos o exemplo inicial, adicionando algumas
outras variáveis, inclusive o objeto do tipo sinal. O segundo exemplo destaca uma outra máquina
de estados, onde a transição de estados é controlada por uma variável “entrada”. A máquina
consiste em quatro estados onde o propósito geral é habilitar a saída “saida” caso na entrada
apresente uma sequência de três 1s.
Código do segundo exemplo
Resultado do segundo exemplo Observamos que na Figura 23, o sinal de saída é “1” quando a entrada permanece em
nível alto por 4 bordas de subida do clock.
Figura 23: Código exemplo2
Figura 24: Resultado do Exemplo2
Tutorial: Active-HDL| Fausto Sampaio
14
Possíveis aplicações No primeiro caso de estudo, o descrição de hardware em VHDL pode ser aplicada
quando se desejar um codificador Gray de 2 bits.
Contudo no segundo caso, pode-se aplicar quando necessário verificar se três objetos
consecutivos foram postos em uma esteira, no qual a saída poderia ser considerada como um
“soar” de um alarme avisando o ocorrido.
Top Related