top of page

Como projetar circuitos estruturados em Verilog

Atualizado: 8 de nov. de 2022

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:

01-ola_mundo
.zip
Fazer download de ZIP • 1KB

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);
endmodule

Salve 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)
    );
endmodule

Mapeando 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.py
Usuá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!

304 visualizações0 comentário

Comments


bottom of page