Dominando Projeto Embarcado com FPGA: Guia Prático de Implementação
A disponibilidade de FPGAs mais potentes e ambientes de programação mais eficazes tornou a implementação com FPGA amplamente acessível, mas usar FPGAs pode parecer intimidador.

Nota do Editor: À medida que algoritmos avançados continuam a surgir para projetos de produtos inteligentes, desenvolvedores frequentemente se veem lutando para implementar sistemas embarcados capazes de atender às demandas de processamento associadas a estes algoritmos. FPGAs podem entregar o desempenho necessário, mas projetar com FPGAs longamente foi considerado limitado ao domínio de especialistas em programação FPGA. Hoje, no entanto, a disponibilidade de FPGAs mais potentes e ambientes de desenvolvimento mais eficazes tornou o desenvolvimento FPGA amplamente acessível. Neste trecho, Capítulo 4 do livro Architecting High-Performance Embedded Systems, o autor oferece uma revisão abrangente de dispositivos FPGA, linguagens de implementação e do processo de desenvolvimento FPGA, bem como um walkthrough detalhado de como começar a implementar FPGAs em seu próprio projeto. O trecho completo é apresentado na seguinte série de parcelas:
1: Recursos de hardware
2: Linguagens de implementação
3: Processo de desenvolvimento
4: Construindo um projeto
5: Implementação (este artigo)
Adaptado de Architecting High-Performance Embedded Systems, por Jim Ledin.
Testando o Comportamento da Lógica
É importante testar o comportamento da lógica usando simulação antes de tentar executá-la no FPGA. Isso porque é muito mais fácil detectar e corrigir problemas no ambiente de simulação do que com a lógica rodando dentro do FPGA. As ferramentas de simulação do Vivado fazem um excelente trabalho representando o comportamento do circuito:
- No sub-janela Sources, clique com botão direito em Simulation Sources e selecione Add Sources…:

Figura 4.18 – Seleção de menu Add Sources… para Simulation Sources
- No diálogo Add Sources, certifique-se que Add or create simulation sources está selecionado, então clique Next.
- No diálogo Add or Create Simulation Sources, clique Create File.
- Digite o nome do arquivo vhdl e clique OK.
- Clique Finish para fechar o diálogo Add or Create Simulation Sources, então clique OK no diálogo Define Module e clique Yes quando perguntado se tem certeza que deseja usar estes.
- Clique duas vezes em Adder4 TestBench (Behavioral) (Adder4TestBench.vhdl) sob Simulation Sources. Apague o conteúdo automaticamente preenchido da janela do editor vhdl e insira o seguinte código no editor Adder4TestBench.vhdl:
library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.NUMERIC_STD.ALL; entity ADDER4_TESTBENCH is end entity ADDER4_TESTBENCH; architecture BEHAVIORAL of ADDER4_TESTBENCH is component ADDER4 is port ( A4 : in std_logic_vector(3 downto 0); B4 : in std_logic_vector(3 downto 0); SUM4 : out std_logic_vector(3 downto 0); C_OUT4 : out std_logic ); end component; signal a : std_logic_vector(3 downto 0); signal b : std_logic_vector(3 downto 0); signal s : std_logic_vector(3 downto 0); signal c_out : std_logic; signal expected_sum5: unsigned(4 downto 0); signal expected_sum4: unsigned(3 downto 0); signal expected_c : std_logic; signal error : std_logic; begin TESTED_DEVICE: ADDER4 port map ( A4 => a, B4 => b, SUM4 => s, C_OUT4 => c_out ); TEST: process begin -- Testa todas as combinações de dois somandos de 4 bits (256 testes totais) for a_val in 0 to 15 loop for b_val in 0 to 15 loop -- Define as entradas para o componente ADDER4 a <= std_logic_vector(to_unsigned(a_val, a'length)); b <= std_logic_vector(to_unsigned(b_val, b'length)); wait for 1 ns; -- Calcula a soma de 5 bits dos dois valores de 4 bits expected_sum5 <= unsigned('0' & a) + unsigned('0' & b); wait for 1 ns; -- Divide a soma em saída de 4 bits e bit de carry expected_sum4 <= expected_sum5(3 downto 0); expected_c <= expected_sum5(4); wait for 1 ns; -- O sinal 'error' só vai para 1 se ocorrer erro if ((unsigned(s) = unsigned(expected_sum4)) and (c_out = expected_c)) then error <= '0'; else error <= '1'; end if; -- Cada passagem pelo loop interno leva 10 ns wait for 7 ns; end loop; end loop; wait; end process TEST; end architecture BEHAVIORAL;
Este código exercita a funcionalidade do somador de 4 bits apresentando todas as combinações de números de 4 bits para cada uma das entradas A4 e B4 do componente Adder4. Ele compara as saídas SUM4 e C_OUT4 do componente Adder4 com valores calculados independentemente para as mesmas entradas. Após cada operação de adição, o sinal error é definido como 0 se as saídas do Adder4 corresponderam aos valores esperados, ou definido como 1 se houver incompatibilidade.
O código em Adder4TestBench.vhdl se assemelha a código de software tradicional na forma como usa loops for aninhados para aplicar todas as combinações de entrada de teste ao componente Adder4 sob teste. Código que roda testes em modo de simulação não é sintetizável, o que significa que não representa puramente um circuito lógico de hardware e é capaz de operações similares a software tradicional, como execução iterativa de loops for.
No entanto, como em circuitos físicos, sinais recebendo valores no código do test bench usando o operador <= não podem ser usados no mesmo instante de tempo em expressões subsequentes. Isso ocorre porque o ambiente de simulação representa os efeitos reais de atraso de propagação, que é significativo mesmo dentro de minúsculos dispositivos FPGA. As três declarações wait for 1 ns; no código do test bench pausam operações do circuito para permitir atraso de propagação. Estes atrasos de 1 ns fornecem tempo para os valores de sinal computados logo antes da declaração wait propagarem para que possam ser usados na declaração seguinte. A declaração final wait for 7 ns; no loop interno é uma pausa que nos permite ver claramente os resultados de cada iteração dos loops de simulação na exibição de rastreamento de sinal.
- Clique com botão direito em Adder4 TestBench (Behavioral) (Adder4TestBench.vhdl) sob Simulation Sources e selecione Automatic Update and Compile Order. Isto define ADDER4_TESTBENCH como objeto top-level para a execução de simulação:

Figura 4.19 – Seleção de menu para definir Automatic Update and Compile Order
- Clique Run Simulation, então Run Behavioral Simulation na janela Flow Navigator para entrar no modo de simulação. Se ainda não salvou os arquivos do editor, será solicitado a fazê-lo. Clique Save. A simulação então rodará:

Figura 4.20 – Seleção de menu Run Behavioral Simulation
- Quando a janela SIMULATION abrir, clique no botão maximizar na janela de saída de simulação com título Untitled 1:

Figura 4.21 – Janela de resultados de simulação
O tempo total simulado de cada passagem pelo loop interno é 10 ns. Como há 256 passagens pelo loop em Adder4TestBench.vhdl, o tempo para rodar a simulação é 2560 ns.
- Defina o tempo de execução da simulação para 2560 ns na barra de ferramentas superior (passo 1 na figura seguinte), pressione o botão de reinício apontando para esquerda (passo 2), então pressione o botão voltado para direita para rodar a simulação por 2560 ns (passo 3), e, finalmente, pressione o botão Zoom Fit (passo 4) para escalar o intervalo de dados de saída da simulação para ajustar à janela:

Figura 4.22 – Resultados de simulação do início ao fim da execução
Você pode usar os ícones de lupa para dar zoom em qualquer ponto do rastreamento e observar os resultados de cada operação de adição realizada durante o teste. Por exemplo, a figura seguinte mostra os valores decimais 6 e 2 foram somados para produzir o resultado 8 com carry 0. Estes valores correspondem aos valores esperados, o que causou error ser definido como 0. O sinal error é 0 para todos os 256 casos de teste, indicando que nosso circuito lógico passou em todos os testes:

Figura 4.23 – Visualização ampliada dos resultados de simulação
- Feche o modo de simulação clicando no X na barra azul SIMULATION acima do rastreamento de dados. Clique OK quando perguntado se deseja fechar a simulação.
Tendo passado no teste comportamental, definiremos os sinais de I/O usados no design.
Definindo Sinais de I/O
Nosso próximo passo é conectar as entradas e saídas do nosso circuito a dispositivos de hardware na placa Arty. As entradas serão as chaves e botões da placa, e as saídas serão LEDs.
Os seguintes passos criarão um arquivo de constraints que descreve os pinos de I/O que usaremos no dispositivo FPGA e as funções conectadas a esses pinos na placa Arty. Arquivos de constraints têm extensão xdc:
- No sub-janela Sources, clique com botão direito em Constraints e selecione Add Sources….
- No diálogo Add Sources, certifique-se que Add or create constraints está selecionado, então clique Next.
- No diálogo Add or Create Constraints, clique Create File.
- Digite o nome do arquivo Arty-A7-100.xdc (ou Arty-A7-35.xdc se apropriado para seu dispositivo) e clique OK.
- Clique Finish para fechar o diálogo Add or Create Constraints.
- Expanda a árvore de fontes Constraints e clique duas vezes em Arty-A7-35.xdc.
- A Digilent fornece arquivos de constraints pré-preenchidos para placas Arty A7. Visite https://raw.githubusercontent.com/Digilent/digilent-xdc/master/Arty-A7-35-Master.xdc e copie todo o conteúdo da janela do navegador para a janela do editor Arty-A7-35.xdc no Vivado. Se apropriado para seu dispositivo, use o arquivo em https://raw.githubusercontent.com/Digilent/digilent-xdc/master/Arty-A7-100-Master.xdc em vez disso.
- Todos os pinos de I/O estão comentados no arquivo de constraints por padrão. Descomente as linhas apropriadas no arquivo removendo o caractere # do início de cada linha. Usaremos os pinos listados nas seções seguintes no arquivo Arty-A7-100.xdc: Switches, RGB LEDs (mas apenas led0_g, o primeiro LED verde), LEDs, e Buttons. A figura seguinte mostra estas linhas após terem sido descomentadas:

Figura 4.24 – Janela do editor de constraints
Na próxima seção, criaremos um arquivo VHDL top-level que interfaceia o código do somador com os dispositivos de I/O.
Criando um Arquivo VHDL Top-Level
Em seguida, criaremos um arquivo VHDL top-level que conecta nosso componente somador de 4 bits aos sinais de I/O correspondentes da placa:
- No sub-janela Sources, clique com botão direito em Design Sources e selecione Add Sources….
- No diálogo Add Sources, certifique-se que Add or create design sources está selecionado, então clique Next.
- No diálogo Add or Create Design Sources, clique Create File.
- Digite o nome do arquivo vhdl e clique OK.
- Clique Finish para fechar o diálogo Add or Create Design Sources, então clique OK no diálogo Define Module e clique Yes quando perguntado se tem certeza que deseja usar estes.
- Clique duas vezes em vhdl sob Design Sources. Apague o conteúdo automaticamente preenchido da janela do editor ArtyAdder.vhdl e insira o seguinte código no editor ArtyAdder.vhdl:
-- Carrega bibliotecas padrão library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity ARTY_ADDER is port ( sw : in STD_LOGIC_VECTOR (3 downto 0); btn : in STD_LOGIC_VECTOR (3 downto 0); led : out STD_LOGIC_VECTOR (3 downto 0); led0_g : out STD_LOGIC ); end entity ARTY_ADDER; architecture BEHAVIORAL of ARTY_ADDER is -- Referencia a definição anterior do componente somador de 4 bits ADDER4 is port ( A4 : in std_logic_vector(3 downto 0); B4 : in std_logic_vector(3 downto 0); SUM4 : out std_logic_vector(3 downto 0); C_OUT4 : out std_logic ); end component; begin ADDER : ADDER4 port map ( A4 => sw, B4 => btn, SUM4 => led, C_OUT4 => led0_g ); end architecture BEHAVIORAL;
Este código mapeia os nomes de sinais para os dispositivos de I/O nomeados em Arty-A7-100.xdc como sw (4 chaves), btn (4 botões), led (4 LEDs de cor única), e led0_g (o canal verde do primeiro LED multi-cor) para as entradas e saídas do ADDER4.
Embora VHDL não seja case-sensitive, o processamento de arquivos de constraint xdc no Vivado é case-sensitive. O caso usado em nomes de dispositivos de I/O definidos no arquivo xdc deve ser idêntico quando referenciado em um arquivo VHDL. Especificamente, os nomes de sinais de I/O em VHDL devem ser minúsculos neste arquivo porque são minúsculos no arquivo de constraints.
Agora estamos prontos para sintetizar, implementar e programar nosso design para a placa Arty.
Sintetizando e Implementando o Bitstream do FPGA
Alternativamente, você pode selecionar Generate Bitstream e o Vivado executará todas as etapas necessárias, incluindo síntese, implementação e geração de bitstream sem intervenção adicional do usuário. Se um erro fatal ocorrer, o processo parará e mensagens de erro serão exibidas. Execute os seguintes passos para gerar o bitstream:
- Clique Generate Bitstream para iniciar o build. Você pode ser perguntado se deseja salvar editores de texto. Clique Save. Pode ser informado que não há resultados de implementação disponíveis e perguntado se está OK lançar síntese e implementação. Clique Yes:

Figura 4.25 – Seleção de menu Generate Bitstream
- O diálogo Launch Runs então aparecerá. Você pode selecionar um valor para Number of jobs até o número de núcleos de processador no seu computador. Usar mais núcleos torna o processo mais rápido, mas pode atrapalhar sua máquina se quiser continuar usando-a durante um processo de build longo. Clique OK para iniciar o build:

Figura 4.26 – Diálogo Launch Runs
- Durante o processo de build, o Vivado exibirá o status no canto superior direito da janela principal. Se necessário, você pode cancelar o processo de build clicando Cancel próximo à exibição de status:

Figura 4.27 – Exibição de status de compilação
- Quando o processo de build completar, assumindo que não houve erros fatais, um diálogo Bitstream Generation Completed aparecerá. Embora outras opções sejam oferecidas, prosseguiremos diretamente para baixar o bitstream para a placa Arty. Selecione Open Hardware Manager e clique OK:

Figura 4.28 – Diálogo Bitstream Generation Completed
Em seguida, baixaremos o bitstream para o FPGA.
Baixando o Bitstream para a Placa
Execute os seguintes passos para baixar o bitstream para uma placa Arty A7:
- O diálogo HARDWARE MANAGER aparecerá e indicará No hardware target is open.
- Conecte sua placa Arty A7-35 ou A7-100 ao computador com USB. Espere alguns segundos para a placa ser reconhecida, então clique Open target, então Auto Connect:

Figura 4.29 – Seleções Open target e Auto Connect
- Após alguns segundos, o Vivado deve indicar que a placa está conectada. Clique Program device para baixar o bitstream do FPGA para a Arty. Você será solicitado a selecionar um arquivo de bitstream. Se usou a mesma estrutura de diretórios deste exemplo, o arquivo estará localizado em C:/Projects/ArtyAdder/ArtyAdder.runs/impl_1/ARTY_ADDER.bit:

Figura 4.30 – Diálogo Program Device
- Clique Program para baixar o programa para o dispositivo FPGA e iniciá-lo
- Agora você pode testar a operação do programa com I/O da Arty. Coloque todas as quatro chaves na posição off (mova as chaves em direção à borda adjacente da placa) e não pressione nenhum dos quatro botões. Todos os quatro LEDs verdes devem estar apagados.
- Se ligar qualquer chave individual ou pressionar qualquer botão, o LED verde correspondente deve acender. Ligar qualquer combinação de chaves enquanto pressiona qualquer número de botões somará os números correspondentes de 4 bits e acenderá os LEDs com o resultado. Se houver carry (por exemplo, ligar SW3 e pressionar BTN3 simultaneamente), o LED de carry verde iluminará.
O processo de programação realizado aqui armazenou o programa na RAM do FPGA. Se você ciclar a energia na placa FPGA, precisará repetir o processo de programação para recarregar o programa. Alternativamente, você pode armazenar o arquivo de configuração do FPGA na memória flash onboard como descrito na seção seguinte.
Programando o Bitstream na Memória Flash Onboard
Para configurar o FPGA cada vez que energia é aplicada à placa Arty, o arquivo de configuração do FPGA deve ser armazenado na memória flash na placa. Se o jumper MODE estiver instalado, o FPGA tentará baixar um arquivo de configuração da memória flash onboard na ligação. Esta memória está localizada em um chip separado adjacente ao FPGA Artix-7. Siga estes passos para programar o arquivo de configuração na memória flash:
- Instale o jumper MODE na placa Arty se ainda não estiver instalado
- Clique com botão direito em Generate Bitstream e selecione Bitstream Settings….
- No diálogo Settings, marque a caixa ao lado de -bin_file e clique OK:

Figura 4.31 – Diálogo Bitstream settings
- No diálogo principal do Vivado, clique Generate Bitstream e repita o processo de geração de bitstream. Clique Cancel quando o diálogo Bitstream Generation Completed aparecer
- No diálogo Hardware, clique com botão direito no número da parte FPGA (xc7a100t_0) e selecione Add Configuration Memory Device…:

Figura 4.32 – Seleção de menu Add Configuration Memory Device…
- Digite s25fl127 na Search. Isto deve trazer um número de peça correspondente. Selecione a peça e clique OK:

Figura 4.33 – Diálogo Add Configuration Memory Device
- Será apresentado um diálogo perguntando Do you want to program the configuration memory device now? Clique OK.
- Isto trará um diálogo Program Configuration Memory Device solicitando o nome do arquivo de configuração. Clique no botão … à direita de Configuration file e selecione C:/Projects/ArtyAdder/ArtyAdder.runs/impl_1/ARTY_ADDER.bin. Clique OK:

Figura 4.34 – Diálogo Program Configuration Memory Device
- O processo de programação levará vários segundos. Você deve receber uma mensagem indicando sucesso após o arquivo ter sido programado na memória flash da placa:

Figura 4.35 – Diálogo Program Flash complete
Após isto, cada vez que você ciclar a energia da placa, o programa do somador de 4 bits carregará e rodará. Levará muito tempo para o programa carregar com as configurações que usamos para carregamento do arquivo de configuração. Para evitar esperar o FPGA carregar o programa, você pode melhorar a velocidade de carregamento do arquivo de configuração executando os seguintes passos:
- Selecione Open Synthesized Design no Flow Navigator.
- No menu principal do Vivado, selecione Tools/Edit Device Properties….
- Na aba General, defina Enable Bitstream Compression como TRUE.
- Na aba Configuration, defina Configuration Rate (MHz) como 33, então clique OK.
- Gere o bitstream novamente, e programe a memória flash como descrito. Você precisará remover o dispositivo de memória de configuração e adicioná-lo novamente para exibir a opção de reprogramação.
- Feche Hardware Manager.
- Desconecte o cabo USB da placa Arty e conecte novamente. O programa deve começar a rodar virtualmente instantaneamente na ligação.
Esta seção apresentou um exemplo de lógica combinacional simples interagindo com sinais nos pinos de I/O do FPGA. A intenção aqui foi familiarizá-lo com a suíte de ferramentas Vivado e demonstrar como as ferramentas são usadas para executar um ciclo completo de desenvolvimento FPGA.
Resumo
Este capítulo começou com uma discussão sobre o uso eficaz de FPGAs em arquiteturas de sistemas embarcados em tempo real e continuou com uma descrição de dispositivos FPGA padrão e os componentes de baixo nível que contêm. A gama de linguagens de design FPGA, incluindo HDLs, métodos de diagrama de blocos, e linguagens de programação de software populares como C/C++, foi introduzida. Um esboço do processo de desenvolvimento FPGA foi apresentado. O capítulo concluiu com um exemplo completo de um ciclo de desenvolvimento FPGA, começando com uma declaração de requisitos e terminando com um sistema funcional implementado em uma placa de desenvolvimento FPGA de baixo custo.
Tendo completado este capítulo, você deve saber como FPGAs podem ser aplicados eficazmente em arquiteturas de sistemas embarcados em tempo real e entender os componentes dentro de um circuito integrado FPGA. Você aprendeu sobre as linguagens de programação usadas no design de algoritmos FPGA, os passos no ciclo de desenvolvimento FPGA, e entende a sequência de passos no processo de desenvolvimento FPGA.
O próximo capítulo expandirá o processo de desenvolvimento FPGA para fornecer uma abordagem completa para arquitetar sistemas embarcados em tempo real contendo FPGAs. Também iniciará o desenvolvimento de um sistema embarcado de alto desempenho protótipo, um osciloscópio digital, que servirá como exemplo para os capítulos seguintes.
Reimpresso com permissão da Packt Publishing. Copyright © 2021 Packt Publishing

Jim Ledin é CEO da Ledin Engineering, Inc. Jim é especialista em design, desenvolvimento e teste de software e hardware embarcados. Também é especialista em avaliação de cibersegurança e testes de penetração de sistemas embarcados. Possui B.S. em engenharia aeroespacial pela Iowa State University e M.S. em engenharia elétrica e de computação pelo Georgia Institute of Technology. Jim é engenheiro elétrico profissional registrado na Califórnia, Certified Information System Security Professional (CISSP), Certified Ethical Hacker (CEH), e Certified Penetration Tester (CPT).
Conteúdos Relacionados:
- Design embarcado com FPGAs: Recursos de hardware
- Design embarcado com FPGAs: Linguagens de implementação
- Design embarcado com FPGAs: Processo de desenvolvimento
- Ferramentas open-source ajudam a simplificar programação FPGA
- Implementando algoritmos de ponto flutuante em FPGAs ou ASICs
- Aproveitando FPGAs para deep learning
- Ferramentas de software migram código GPU para FPGAs para aplicações AI
Para mais Embedded, assine a newsletter semanal por e-mail da Embedded.
Integrado
- Design de Sistemas Embarcados: Passos, Princípios e Aplicações Reais
- Colorindo Peças Impressas em 3D com Giz de Cera: Uma Nova Técnica de Pós-Processamento
- Entrevista com Tecnólogo Chefe da ANSYS: Impulsionando Sucesso na Impressão 3D de Metal Através de Simulação
- Aproveitando IA Embarcada para Converter Big Data em Insights Inteligentes Acionáveis
- Dominando USB-C: Desafios de Design e Soluções Práticas para Dados de Alta Velocidade e Energia
- Tendências de Design Embarcado Remodelando o Futuro da Tecnologia
- Foundries.io Visa Ser Red Hat do IoT com Linux & Zephyr Processor-Agnostic
- Clientron PST650: Terminal POS Tudo-em-Um com Impressora Térmica Integrada para Hotelaria e Retalho
- MAXREFDES220# – Monitoramento de Pressão Arterial sem Manguito com Sensores Ópticos
- Maximizando Produção com Software Avançado de Manufatura Aditiva