Um projeto hierarquico permite o desenvolvimento de sistemas complexos a partir de subsistemas mais simples. Utilizando-se do conceito de hierarquia, é possível compor circuitos com uma infinidade de subcircuitos mais simples, tornando o todo um sistema muito mais complexo. Neste tutorial, iremos hierarquizar o projeto "Olá Mundo", utilizando a hierarquia de módulos em Verilog.
Neste tutorial, você vai aprender a:
reprojetar o circuito "Ola Mundo" através de subsistemas (ou módulos)
criar módulos em Verilog para cada um dos circuitos que imprime as letras 'O', 'L' e 'A' no display da S-Board
estruturar um projeto hierárquico utilizando construções em Verilog
mapear as portas do circuito para o display da S-Board
compilar e prototipar um projeto hierárquico na S-Board
ler e compreender o relatório resumido do projeto
interagir com um projeto hierárquico na S-Board
Clique no link abaixo para baixar o código para este tutorial:
Antes de prosseguir, recomendamos al eitura do seguinte tutorial
Reprojetando o circuito "Ola Mundo"
O circuito "Ola Mundo" possui um único arquivo Verilog contendo toda a descrição do circuito. Para reprojetá-lo de forma hierarquizada, precisamos decidir quais partes do circuito serão transformados em módulos (ou subsistemas). Neste tutorial, vamos modularizar os circuitos relacionados com cada uma das letras; e começaremos modularizando o subcircuito que ativa/desativa os segmentos que compõe a letra 'L'. Para isso, iremos substituir os 3 buffers indicados na figura abaixo por um módulo chamado de 'letra_l'.
Na figura acima, os três sinais de saída dos buffers foram substituídos por um barramento de 3 bits de largura. Essa alteração foi realizada para simplificar o esquemático, e é comumente encontrada em projeto de circuitos digitais. Tabelas também são muito utilizadas em circuitos digitais. Através delas, descrevemos a interface de módulos. A exemplo disso, segue descrição da interface do módulo 'letra_l':
Porta | Direção | Bits | Descrição |
ativa | entrada | 1 | Ativa os 3 segmentos necessários para a imprimir a letra 'L' no display. |
dp_seg[2:0] | saída | 3 | Sinais que compõem a letra 'L' em um display de sete segmentos. |
Descrevendo os módulos em Verilog
Com o projeto do módulo 'letra_l' encerrado, podemos partir para a implemetação em código Verilog. Abaixo, segue a descrição do módulo:
module letra_l(
// Sinal de entrada conectado a chave
// que ativa a letra 'L'
input ativa,
// Sinais de saida conectados ao display
// de sete segmentos que compoem a letra 'L'
output [2:0] dp_seg
);
// Circuito que ativa os
// segmentos que compoem a letra 'L'
buf(dp_seg[2],ativa);
buf(dp_seg[1],ativa);
buf(dp_seg[0],ativa);
endmoduleDescreva o código acima no editor Verilog da Pitanga IDE. Seguindo o mesmo procedimento, tente descrever por você mesmo os módulos 'letra_o' e 'letra_a', descrevendo-os no editor Verilog. Caso não consiga, o código para ambos os módulos encontra-se logo abaixo:
letra_o.v
letra_a.v
Criando a hieraquia de módulos
Agora que cada um dos módulos 'letra_o', 'letra_l' e 'letra_a' estão descritos em Verilog, precisamos criar o módulo topo que irá instanciá-los. Este módulo é chamado de ola_mundo e representa o topo da hierarquia de módulos deve estar no editor Verilog acima dos outros módulos. Em outras palavras, este módulo instancia todos os outros módulos, conforme indicado no esquemático abaixo.
Módulos no arquivo topo podem ser instânciados através da seguinte sintaxe:
nome_do_modulo nome_da_instancia(
.porta_do_modulo(sinal_mapeado),
.porta_do_modulo(sinal_mapeado),
...
.porta_do_modulo(sinal_mapeado)
);Aplicando a sintaxe no esquemático acima, obtemos o seguinte código para o arquivo ola_mundo.v:
module ola_mundo(
// Sinais de entrada conectados as chaves
// sw2, sw1 e sw0 da placa Pitanga
input chave_o,
input chave_l,
input chave_a,
// Sinais de saida conectados aos displays
// de sete segmentos da placa Pitanga
output [5:0] O,
output [2:0] L,
output [5:0] A
);
// Circuito que liga e desliga os
// segmentos que compoem a letra 'O'
letra_o DISPLAY_O(
.ativa(chave_o),
.dp_seg(O)
);
// Circuito que liga e desliga os
// segmentos que compoem a letra 'L'
letra_l DISPLAY_L(
.ativa(chave_l),
.dp_seg(L)
);
// Circuito que liga e desliga os
// segmentos que compoem a letra 'A'
letra_a DISPLAY_A(
.ativa(chave_a),
.dp_seg(A)
);
endmoduleMapeando as portas na S-Board
O circuito hierarquizado está pronto, mas falta o arquivo de pinagem (.pinout) para poder prototipá-lo na placa Community. Esta etapa segue os mesmos passos do tutorial anterior. De toda a forma, colocamos o código da pinagem do ola_mundo abaixo para a sua conveniência.
// Porta Verilog Componentes da Placa
// Mapeia portas de entrada para as chaves
chave_a = sw0;
chave_l = sw1;
chave_o = sw2;
// Mapeia portas de saida correspondendo as
// letras 'O', 'L' e 'A' para o display de sete
// segmentos
O[5] = segd3.f_on;
O[4] = segd3.e_on;
O[3] = segd3.d_on;
O[2] = segd3.c_on;
O[1] = segd3.b_on;
O[0] = segd3.a_on;
L[2] = segd2.f_on;
L[1] = segd2.e_on;
L[0] = segd2.d_on;
A[5] = segd1.g_on;
A[4] = segd1.f_on;
A[3] = segd1.e_on;
A[2] = segd1.c_on;
A[1] = segd1.b_on;
A[0] = segd1.a_on;
Note que o arquivo de mapeamento é exatamente o mesmo utilzado no tutorial anterior.
Compilando o projeto
O processo de compilação traduz os arquivos verilog e de pinagem para as células lógicas disponíveis no vPLD Pitanga. É através da compilação que o circuito digital é construído. Para realizar a compilação, veja o vídeo a seguir:
Caso você não tenha cometido nenhum erro de codificação no Verilog, será impresso no terminal de texto o relatório com o resumo do projeto. Note que o relatório contém a mesma quantidade de buffers utlizados no projeto anterior.
DESIGN SUMMARY REPORT
module : ola_mundo
design file: pitanga.v
pinout file: pitanga.pinout
Total number of wire: 18
Total number of cells: 15
Total number of ports: 20
Cell Instances Cell Instances Cell Instances
-----------------------------------------------------------------------------
AND2 0 | NAND2 0 | XOR2 0
AND3 0 | NAND3 0 | XOR3 0
AND4 0 | NAND4 0 | XOR4 0
OR2 0 | NOR2 0 | XNOR2 0
OR3 0 | NOR3 0 | XNOR3 0
OR4 0 | NOR4 0 | XNOR4 0
-----------------------------------------------------------------------------
BUF 15 | INV 0 | DFFRSE 0
Cells utilization: 15
Transistor count : 60/4000 transistors (1.50 %)
Por fim, clique nas chave sw2, sw1, sw0 e verifique se a palavra 'OLA' aparece no display de sete segmentos. O resultado esperado é mostrado na figura a seguir.
Conclusão
Parabéns! Você acaba prototipar um circuito digital sem utilizar FPGAs. Com o auxílio da Placa Virtual Pitanga e do chip virtual lógico programável Pitanga, você obteve a experiência de hierarquizar um circuito digital em Verilog sem gastar um tostão comprando protoboards ou placas baseadas em FPGAs. Saiba que este mesmo projeto em Verilog pode ser prototipado em uma placa baseada em FPGA, funcionando da mesma forma, desde que a mapemaneto seja realizado corretamente para o display de sete segmentos da placa-alvo.
Você sabia que a placa pode ser utilizada na sua instituição de ensino? Entre em contato conosco e saiba como!
onde consigo o dicionario da aplicação?