Um projeto estruturado 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 estruturar 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 placa Community
estruturar um projeto hierárquico utilizando construções em Verilog
mapear as portas do circuito para o display da placa Community
compilar e prototipar um projeto hierárquico na placa Community
ler e compreender o relatório resumido do projeto
interagir com um projeto hierárquico na placa Community
Clique no link abaixo para baixar o código para este tutorial:
Antes de prosseguir, recomendamos os seguintes tutoriais
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 estruturada, 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);
endmoduleSalve o código acima em um arquivo chamado letra_l.v. Seguindo o mesmo procedimento, tente descrever por você mesmo os módulos 'letra_o' e 'letra_a', salvando-os em arquivos 'letra_o.v' e 'letra_a.v', respectivamente. 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 um outro arquivo para instanciá-los. Este arquivo é chamado de ola_mundo.v, e é o arquivo topo da hierarquia. Em outras palavras, o arquivo topo é o que instancia todos os outros arquivos, 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 placa Community
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 arquivo ola_mundo.pinout 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 ola_mundo.v e ola_mundo.pinout para as células lógicas disponíveis no chip Pitanga. É através da compilação que o circuito digital é construído. Para realizar a compilação, siga as instruções abaixo:
1) Abra a placa Community
. pitanga.sh
python pitanga.pyUsuários Windows podem abrir a placa Community com um duplo clique no link Pitanga
2) Clique no botão "Upload Files" e selecione os arquivos ola_mundo.v, letra_o.v, letra_l.v, letra_a.v e ola_mundo.pinout. Em seguida, clique em "Run".
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: ola_mundo.v
pinout file: ola_mundo.pinout
Total number of wires: 0
Total number of cells: 15
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/500 cells (3.0 %).
3) 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 Community e do chip programável Pitanga, você obteve a experiência de estruturar 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.
Você sabia que a placa Student possui um chip Pitanga mais rápido e com mais células lógicas do que a placa Community? E que a placa Student não possui limitação de usuários? Então, considere assinar um de nossos planos. Entre em contato com a gente!