Hello World! Como prototipar "Olá Mundo" no chip virtual Pitanga
Atualizado: 5 de abr.
O "Olá Mundo" (ou "Hello World") é um nome utilizado em tutoriais de linguagens de programação para a implementação de um primeiro programa simples e funcional. No mundo da programação, o "Olá Mundo" normalmente escreve a frase "Hello World!" em um terminal de texto. Neste tutorial, você vai aprender a projetar um circuito digital que escreve "OLA!" no display de sete segmentos da placa Pitanga Community.
Neste tutorial, você irá aprender a:
projetar um circuito que imprime no display de sete segmentos
descrever em Verilog um circuito que imprime a letra 'L'
mapear as portas de um circuito em Verilog para o display da placa Community
compilar e prototipar um circuito que imprime a letra 'L' na placa Community
ler e compreender o relatório resumido do projeto de um circuito digital
compilar, executar e interagir com o projeto "Ola Mundo" na placa Community
Entendendo o projeto do circuito
O circuito digital para a implementação deste projeto é bem simples e não exige muito conhecimento em lógica digital. O único trabalho a se realizar é a conexão das chaves para o display de sete segmentos, que será realizada por intermédio do chip virtual Pitanga. Os segmentos do display da placa Pitanga Community são ativos em nível lógico '1' (VCC). Sendo assim, precisamos conectar os segmentos corretos ao nível lógico '1' (VCC) para escrever a letra 'L' no display. Abaixo, segue esquemático do projeto do circuito:
Note que o dispositivo que conecta a chave sw1 ao display de sete segmentos é um buffer (representado por triângulos). Há três buffers, um para cada segmento do display que forma a letra 'L'. Estes buffers estão presentes no chip virtual programável Pitanga, e serão descritos em Verilog na sessão a seguir.
Descrevendo o circuito em Verilog
O chip virtual Pitanga possui diversas células lógicas (ou portas lógicas). Dentre elas, temos os buffers, que são portas que apenas transmitem o sinal de entrada para a saída sem realizar alteração alguma no sinal. Abaixo, temos um esquemático um pouco mais detalhado do mesmo circuito, indicando que os buffers são células do chip virtual Pitanga. Estas células serão utilizadas para conectar a chave sw1 ao display de sete segmentos.
A partir do esquemático, vamos descrever o circuito que faz a interface entre o display de sete segmentos e a chave sw1 da placa Community. Inicialmente, vamos declarar os sinais de interface, que são: L[2], L[1], L[0] e chave_l. Estes sinais devem ser codificados na construção module em Verilog, conforme indicado abaixo:
module ola_mundo(
// Sinal que liga e desliga a letra 'L'
input chave_l,
// Vetor de sinais conectado aos segmentos
// que formam a letra 'L'
output [2:0] L
);O sinal de saída L é um vetor. Vetores em Verilog são declarados através da estrutura de colchetes. Os sinais individuais do vetor L pode ser acessados da seguinte forma: L[0], L[1] e L[2].
Em seguida, logo abaixo da construção module, vamos descrever a lógica do circuito digital que, neste caso, são os três buffers conectados a chave externa chave_l.
// Circuito que liga e desliga os
// segmentos que compoem a letra "L"
buf(L[2],chave_l);
buf(L[1],chave_l);
buf(L[0],chave_l);E, por fim, vamos adicionar a diretiva endmodule encerrando, assim, nosso módulo ola_mundo.
endmoduleO código completo do circuito em Verilog é mostrado a seguir:
module ola_mundo(
// Sinal que liga e desliga a letra 'L'
input chave_l,
// Vetor de sinais conectado aos segmentos
// que formam a letra 'L'
output [2:0] L
);
// Circuito que liga e desliga os
// segmentos que compoem a letra "L"
buf(L[2],chave_l);
buf(L[1],chave_l);
buf(L[0],chave_l);
endmoduleMapeando o circuito Verilog na placa Community
O circuito está pronto e descrito em Verilog, mas falta conectá-lo aos componentes da placa Community (chave e display). Cada componente da placa possui um nome. Este nome pode ser identificado pela serigrafia, com exceção dos segmentos individuais do display. Para descobrir o nome de cada um dos segmentos do display, precisamos utilizar a figura abaixo:
Agora que sabemos os nomes dos identificadores dos componentes, iremos conectar as portas de entrada e saída do circuito Verilog aos componentes da placa. Para isso, será necessário um arquivo texto. Este arquivo deve ter o mesmo nome do módulo Verilog, adicionando a extensão .pinout ao final.
// Porta Verilog Componente da Placa
// Mapeia portas de entrada para as chave sw1
chave_l = sw1;
// Mapeia portas de saida correspondendo a
// letra 'L' para o display de sete segmentos
L[2] = segd2.f_on;
L[1] = segd2.e_on;
L[0] = segd2.d_on;Note que o arquivo de mapeamento representa, de forma textual, o esquemático indicado na figura abaixo:
Encerrada esta etapa, vamos para o processo de compilação e prototipação do projeto.
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 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. Neste relatório, você irá notar que os buffers projetados estão contabilizados na última linha da primeira coluna.
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: 3
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 3 | INV 0 | DFFRSE 0
Cells utilization: 3/500 cells (0.6 %).3) Por fim, clique na chave sw1 e verifique se a letra 'L' aparece no display segd2. O resultado esperado é mostrado na figura a seguir.
Se você conseguiu imprimir a letra 'L', então será fácil escrever "OLA" no display da placa Community. Basta replicar o conceito deste projeto para as letras 'O' e 'A'. Tome um tempo e tente fazer por você mesmo. Caso contrário, vá para a seção a seguir.
Prototipando "Ola Mundo" na placa Community
O projeto "Ola Mundo" tem o seguinte comportamento na placa Community:
sw2: habilita/desabilita a letra 'O' no display segd3
sw1: habilita/desabilita a letra 'L' no display segd3
sw0: habilita/desabilita a letra 'A' no display segd3
Os arquivos deste projeto são ola_mundo.v e ola_mundo.pinout. Estes arquivos estão logo abaixo e devem ser compilados no chip Pitanga. Caso tenha dúvidas de como fazer, siga as etapas indicadas nas seções anteriores.
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"
buf(O[5],chave_o);
buf(O[4],chave_o);
buf(O[3],chave_o);
buf(O[2],chave_o);
buf(O[1],chave_o);
buf(O[0],chave_o);
// Circuito que liga e desliga os
// segmentos que compoem a letra "L"
buf(L[2],chave_l);
buf(L[1],chave_l);
buf(L[0],chave_l);
// Circuito que liga e desliga os
// segmentos que compoem a letra "A"
buf(A[5],chave_a);
buf(A[4],chave_a);
buf(A[3],chave_a);
buf(A[2],chave_a);
buf(A[1],chave_a);
buf(A[0],chave_a);
endmoduleola_mundo.pinout
// 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;O resultado da compilação será o vídeo indicado no início deste tutorial. Este projeto possui 15 buffers e utiliza 3% da capacidade de células disponíveis no chip virtual Pitanga. O resumo do projeto encontra-se no relatório a seguir:
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 %).Conclusão
Parabéns! Você acaba de 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 desenvolver um circuito digital em Verilog sem gastar um tostão comprando protoboards ou placas baseadas em FPGAs. Este mesmo Verilog pode ser compilado em uma placa real, funcionando da mesma forma, desde que a placa real tenha 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!