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:

• Nexys 4
• Basys 3
• Arty

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:

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.