ÍNDICE DE CONTEÚDO
Em meu último artigo no site eu fiz uma rápida introdução da plataforma de desenvolvimento baseada no SoC Zynq 7000 da Xilinx, a Zybo board. Atualmente os SoCs (System-on-chip) vêm se tornando uma alternativa para aplicações embarcadas que envolvam paralelismo e alto poder de processamento. Diferente das tradicionais FPGAs, esses incorporaram programação em linguagens como C/C++, além das tradicionais HDLs.
No caso específico da Xilinx, a transição para as ferramentas de desenvolvimento baseadas em SoCs veio acompanhada do lançamento de um novo software de desenvolvimento, o Vivado Design Suite.
O Vivado Design Suite tem como um dos lemas multiplicar a produtividade em termos do desenvolvimento embarcado baseado em suas FPGAs/SoCs. Além dos SoCs, a nova linha de FPGAs da empresa conta com suporte exclusivo através do Vivado. Detalhes a parte, o uso do Vivado para programação de FPGAs/SoCs para usuários acostumados com o ISE Design Suite, software anterior da Xilinx, pode parecer um pouco difícil no primeiro instante.
Devido ao suporte de diversos IPs e ferramentas distintas, o programa pode parecer um pouco confuso e difícil para usuários que desejam apenas fazer um simples projeto RTL baseado em alguma HDL (Hardware Description Language) como VHDL/Verilog/System Verilog.
O artigo do Francesco Sacco descreve perfeitamente o uso do ISE Design Suite para simulação de código HDL no ISE. O objetivo deste artigo é mostrar um rápido tutorial para programação de FPGAs/SoCs da Xilinx utilizando o Vivado. Como referência, irei me direcionar para as placas/plataformas de desenvolvimento da Digilent: com Zynq e Artix 7.
Listo abaixo a nova linha de placas, além daquelas baseadas no SoC Zynq 7000, de desenvolvimento da Xilinx que utiliza a plataforma Vivado para desenvolvimento:
Onde posso baixar/adquirir o Vivado?
Não muito diferente de outro software, para a instalação do Vivado temos as duas possibilidades: instalação a partir DVD da Xilinx ou instalação a partir de arquivo baixado da internet. Algumas licenças do Vivado são distribuídas com alguma placa de desenvolvimento da Xilinx, essas licenças por muitas vezes dão direito a uma variedade maior de IPs.
Para a instalação tradicional a partir do instalador baixado, você pode seguir este tutorial como referência.
Criando novo projeto RTL com o Vivado
Como citado anteriormente, o objetivo do artigo é a criação de um projeto RTL no Vivado baseado na linguagem Verilog. Existem algumas maneiras diferentes de fazer o projeto RTL, como exemplo podemos instanciar o IP próprio do Zynq 7000 referente à parte de lógica programável ou criação de um projeto RTL. Para os que possuem FPGAs compatíveis com o Vivado, o procedimento será o mesmo utilizado neste tutorial (utilizo como referência para o tutorial a Zybo board).
Material necessário para a criação do projeto:
- Placa de desenvolvimento FPGA Xilinx (uma das listadas acima) ou placa baseada em Zynq 7000 (Zybo/Zedboard);
- Software Vivado instalado.
Inicialmente estarei descrevendo o nosso projeto teste: que consiste em acender um dos quatro LEDs da placa Zybo a medida que uma das quatro switches da placa seja acionada.
O código em Verilog (também disponível no GitHub) para tal projeto é descrito abaixo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
module LEDtest (clk,sw,led); // =========================================================================== // Definir Input e Outputs do modulo // =========================================================================== input clk; // Master clock da FPGA/SoC input [3:0] sw; // Entradas do modulo, chaves da placa output [3:0] led; // Saida do Modulo, 04 LEDs // ----------------------------------------------------- reg [3:0] leddata; always@(posedge clk) begin leddata=sw; end assign led[3:0] = leddata[3:0]; endmodule // declaracao de fim de modulo |
Um código simples onde as entradas são o clock master da placa e os switches, como saída temos as quatro saídas digitais correspondentes aos LEDs.
A Fig. 2 ilustra as partes da placa usadas para o projeto.
A partir de agora iremos iniciar o Vivado e iniciar a criação do projeto. Siga os próximos passos!
A.1 – Assim que abrir o software Vivado, na página inicial, aperte em Create New Project.
A.2 – Nomeie o seu projeto, no meu exemplo coloquei LEDtest como na Figura 3.
A.3 – O próximo passo é determinar o tipo de projeto, como estamos apenas montando um projeto RTL (a partir de linguagem HDL), escolha a opção RTL Project (Figura 4).
A.4 – O próximo passo será determinar o tipo de placa/plataforma que iremos implementar o projeto. No meu caso escolhi a Zybo board, caso você tenha outra placa FPGA/SoC, escolha sua correspondente plataforma, como mostra a Figura 5.
Caso você esteja usando uma placa da Digilent que não esteja listada na sua versão do software Vivado, tente atualizar a versão ou procurar alguma referência na documentação do site da Digilent.
A.5 – Com a escolha do tipo de projeto feita e placa de desenvolvimento, estamos prontos para finalizar a iniciação do novo projeto. Siga os indicativos de Next nos botões do software e estando tudo certo você deverá ver uma imagem indicativa com New Project Sumary e com uma breve descrição do projeto.
Nossa próxima etapa será adicionar módulos HDL ao projeto.
Adicionando módulos HDL ao projeto
A partir do código descrito anteriormente, torna-se necessário adicionar o mesmo para fazer parte do projeto no Vivado. Em projeto com código únicos, como este, esta etapa se resume a adicionar apenas um arquivo Verilog/VHDL. Em projetos contendo vários códigos, você pode adicionar os códigos de um único instante ou até mesmo escrevê-los no Vivado, criando um código.
Siga os passos para adicionar um arquivo, módulo HDL, ao projeto.
B.1 – Com a janela principal do programa aberta você deverá clicar com o botão direito em Design Sources e clicar em Add Sources, como mostrado na Figura 6.
Como mostra a Figura 7, adicione um arquivo Verilog ao projeto.
Em seguida será pedido para adicionar um arquivo já existente ou criar um novo. Caso você tenha salvo o arquivo .v com código em algum diretório do computador, adicione. Caso contrário, crie um novo e copie e cole o código no arquivo. A Fig. 8 mostra a opção de criar.
B.2 – Em seguida, após a criação e opção de salvar o novo arquivo .v criado, você deverá ter algo parecido com a Figura 9. Lembre de salvar preferencialmente o top module HDL com o mesmo nome do projeto.
B.3 – Após ter adicionado o módulo HDL ao projeto, faz-se necessário agora adicionar o arquivo .XDC para o respectivo projeto. Este tipo de arquivo é único para cada placa de desenvolvimento e FPGA. Você pode encontrar os diversos arquivos .XDC para as plataformas da Digilent/Xilinx no site da Digilent. Para os que estão usando a Zybo board, segue um link direto para o arquivo .XDC que está no meu GitHub.
Vá na pasta Constraints e clique com o botão direito para adicionar New Source. Você pode criar o arquivo .XDC ou indicar algum diretório do computador onde o mesmo se situa. As Figuras 10 e 11 ilustram o processo.
B.4 – Independente da opção que você escolheu, seja adicionar ou criar o arquivo, faz-se necessário editar o arquivo .XDC. O funcionamento dele é baseado em que as linhas comentadas não fazem parte das I/Os utilizadas no projeto. Caso você tenha dúvida de qual I/O utilizará em seu projeto HDL, recomendo utilizar o manual do usuário da sua placa de desenvolvimento.
Para seguir o presente tutorial usando a Zybo board, descomente as linhas mostradas nas próximas imagens.
Note que basicamente as linhas usadas no arquivo .XDC correspondem aos switches e CLK master da placa, as entradas do módulo HDL, e a saída que corresponde aos quatro LEDs.
Implementando o projeto RTL no Vivado
Os próximos passos após a adição dos módulos HDL e arquivo .XDC é a implementação do projeto no Vivado. A implementação é a penúltima etapa, sendo a programação da placa, geração do bitstream, a última.
C.1 – Com os passos anteriores feitos, clique em RUN Implementation no Vivado (Figura 14).
C.2 – Com o código estando certo, e espero que esteja, o programa informará que a implementação foi realizada com sucesso. Você deverá ver uma imagem como a Figura 15.
Caso você seja curioso como eu e queira ter a garantia que seu projeto foi implementado 100% corretamente, antes de programá-lo na placa, você pode visualizar o RTL schematic do mesmo. Clique na opção View RTL schematic. Para o caso do projeto atual, a Fig. 16 ilustra o código implementado.
Note que o diagrama de blocos do projeto implementado representa um Flip-Flop, que faz sentido com o código implementado.
Programando a placa de desenvolvimento
D.1 – Com o projeto implementado, gere o bitstream. Caso esteja tudo ok, você deverá receber a confirmação.
D.2 – Agora chegou a hora de programar o projeto na placa. Vá na página do Vivado correspondente a Program and Debug e defina sua placa (COM A MESMA CONECTADA NA USB!!). Após o software reconhecer o modelo da placa, você poderá programar o arquivo .bit gerado para a placa.
Pronto!! Após todos esses passos o seu projeto RTL estará na placa e você poderá usar a sua FPGA/Soc com seu projeto.
Em seguida mostro brevemente em vídeo sobre a implementação do projeto com o Vivado.
Considerações finais
O objetivo do artigo foi introduzir a programação e construção de projeto RTL utilizando o Vivado Design Suite. Existem outras formas de implementar um projeto RTL, utilizando os módulos do próprio Vivado em conjunto com outros IPs.
Como objetivo de uma série de artigos sobre a Zybo board/Vivado, espero escrever num próximo a integração entre parte de lógica programável e ARM, através do barramento AMBA.
Espero que tenham gostado! Um forte abraço.
Engenheiro da Computação no Centro de Estudos e Sistemas Avançados do Recife (C.E.S.A.R). Mestre em Ciência da Computação no Centro de Informática da Universidade Federal de Pernambuco (CIn-UFPE). Engenheiro Eletrônico pela Universidade Federal de Pernambuco (DES-UFPE). Possui experiência profissional no desenvolvimento de sistemas embarcados e em Eletrônica Digital com dispositivos lógico programáveis (CPLDs e FPGAs).
Erodines, tem previsão de publicação do próximo artigo (parte de lógica programável e ARM)?