Primeiros passos de FPGA com a Papilio One Deixe um comentário

Se você é aluno de algum curso de Ciência ou Engenharia da Computação, ou ainda algum curso correlato, já deve ter ouvido falar sobre as tão famosas “FPGAs” – Chips reprogramáveis com alta capacidade lógica e capazes de executar toda sorte de atividades. Normalmente restritas ao nicho universitário ou de computação de alto desempenho, a FilipeFlop  busca trazer ao público brasileiro um melhor acesso a essa tecnologia por meio da Papilio One – Uma placa com FPGA com quase o tamanho de um Arduino UNO. Mas… Em termos de Embarcados, pra que serve isso? Como isso pode mudar ou influenciar minha vida? Pode ser programado com Arduino? Já dando um leve spoiler, vocês verão que para o caso da Papilio One a resposta dessa última pergunta é… Sim! 😉

Mas afinal… O que é FPGA?

FPGA é a abreviação de Field Programmable Gate Array – algo como “Matriz de Portas Programáveis em Campo”. Em outras palavras, é um chip reprogramável a nível de portas lógicas!

Portas lógicas correspondem a unidade elementar de qualquer circuito digital. Abaixo dela estão, literalmente, os transistores. Analogamente aos nossos organismos, as portas lógicas são as células que compõem os “órgãos” de sistema digital, tais como CPU, Memória, UART, Timers, GPIO, etc.

 

Portas lógicas
Figura 1 – Portas lógicas. Fonte: https://learn.sparkfun.com/tutorials/digital-logic

E por que  um FPGA é diferente de um Arduino da vida? É porque um Arduino (metonímia que se tornou um Atmega328, por exemplo) é um chip em que suas portas-lógicas estão em um arranjo “fixo”, enquanto que na FPGA esse “arranjo” não é fixo, podendo ser alterado. Ou seja, em um microcontrolador você não muda as características da CPU, a quantidade de memória RAM ou Flash, etc. A única coisa que você realmente muda em um microcontrolador é o programa gravado nele. Caso queira mudar recursos físicos, é preciso comprar outro Arduino (ou outro microcontrolador…), com outras configurações.

Já em uma FPGA você é capaz de criar todo um sistema lógico do seu jeito, respeitando, é claro, as limitações que o chip também possui. Analogamente a um microcontrolador possui um limite de memória para os programas que podem ser gravados, as FPGAs possuem uma dada quantidade de “lógica”, que corresponde a quantidade de recursos (lógicos) que o chip possui para incorporar funções.

Basicamente, as FPGAs incorporam como unidade fundamental o chamado “Elemento Lógico”, que é uma composição de portas lógicas capazes de desempenhar uma sorte de operações lógicas conforme  seja configurada, e ainda assim é capaz de armazenar memória também (mesmo que 1 bit). A Xilinx normalmente usa a atribuição de LUT (Look-Up Table), já a Altera (outra fabricante de FPGAs) gosta de usar a nomenclatura LE (Logic Element – Elemento Lógico). No fim das contas, é praticamente a mesma coisa. Eu, particularmente, tenho mais gosto por chamar de Elementos Lógicos (LE).

Elemento lógico básico de uma FPGA
Figura 3 – Elemento lógico básico de uma FPGA. Fonte: https://www.eetimes.com

Uma FPGA incorpora uma boa quantidade de Elementos Lógicos, que podem ser agrupados por regiões maiores formando blocos de elementos, e esses blocos por sua vez conectados por barramentos capazes de ligar outros blocos, sinais de entrada e saída, etc.

Blocos lógicos FPGA
Figura 4 – Elementos lógicos em uma FPGA. Fonte: https://www.eetimes.com

Cada elemento lógico pode ser configurado para desempenhar uma função lógica (AND, OR, XOR, NOT, etc). Agrupe e conecte vários elementos lógicos, blocos lógicos,  e você terá funções lógicas mais e mais complexas, que podem ser agrupadas para formar todo um sistema mais complexo ainda, tal como uma CPU, RAM, UART, GPIO, controlador de Rede, sistema de criptografia e até mineração de Bitcoin.

Lidar com FPGAs foge à regra-comum normalmente adotada em microcontroladores, pois você irá arquitetar um sistema lógico para uma determinada tarefa. Isso envolverá o emprego de outras ferramentas de desenvolvimento e outras linguagens de programação – ou, como manda a formalidade – linguagens de síntese, pois você irá determinar a síntese de um dado circuito/sistema.

E nessa descrição estou sendo bem resumido. As FPGAs modernas incorporam componentes cada vez mais sofisticados, tais como bancos de memória dedicados, Controladores de Clock/PLL, dentre outros. A boa notícia é que a Papilio One se encaixa nessas modernas FPGAs, mas é tanto assunto que o aprofundamento ficará para próximos posts e exemplos.

Dentre as inúmeras possibilidades (algumas já citadas), você pode, inclusive, mimetizar um microcontrolador em FPGA. Cansou? Ela pode ser zerada e regravada com outra “lógica”, como um sistema de som, vídeo, rede, etc.

Com o Papilio One você é capaz de “programar” a FPGA dela para se passar por um Arduino, e programá-la com a mesma facilidade do Arduino IDE.

Uma FPGA Espartana com a Papilio One

De forma resumida, a Papilio é uma placa de desenvolvimento Open Source para FPGA, baseada no FPGA Xilinx Spartan 3E. Em se tratando da Papilio One, a placa possui 48 sinais de GPIO, USB de 2 canais (via chip FTDI), programador JTAG integrado (no próprio FPGA Xilinx!), 4 fontes de alimentação diferentes e conexão com fonte externa.  De acordo com os criadores, é um básico e essencial para que estudantes e entusiastas consigam adentrar o mundo da lógica digital programável. E eu concordo com eles.

Xilinx Spartan

O pessoal por trás do projeto é o Gadget Factory, e eles concentram a maior parte das novidades e contato com a comunidade por meio do Fórum Gadget Factory (onde eu, por sinal, encontrei boa parte das informações para esse post).

Existem outras fabricantes de FPGAs no mercado (assim como existem diversas fabricantes de microcontroladores diferentes também), mas a Xilinx é que foi a pioneira na tecnologia de FPGAs, tendo sido a primeira empresa a lançar a tecnologia.

Além do mais, o Xilinx Spartan 3E, o coração da Papilio One, é bem versátil, e somado a outros pequenos recursos, mas muito úteis, tornam a Papilio One uma placa bem prática para mexer como vocês vão ver a seguir.

A placa em si é simples, tendo todos os componentes na parte superior da placa. Na parte inferior, basicamente estão os pontos de solda dos conectores e algumas trilhas de circuito.

Características da Papilio One

Vamos ver um pouco de cada recurso que a Papilio One oferece, em detalhes:

Fonte de Alimentação

A placa pode ser alimentada tanto via USB (via mais comum), como por uma fonte de alimentação externa. Bem nos moldes do Arduino, diga-se de passagem.

Detalhe fonte

  • 4 trilhas de alimentação independentes de 5 V, 3.3 V, 2.5 V e 1.2 V.
  • Alimentação elétrica por conector de energia ou USB
  • Conector de Energia com entrada de alimentação entre 6.5 a 15 V.
    • Corrente: Até 800mA
    • Dimensão: 2.1mm
    • Polaridade: Positive Tip

USB

Alguns entusiastas de FPGA sabem que para programar esses tipos de circuito são necessários, na maioria das vezes, o uso de (caros) dispositivos externos. No caso da Spartan 3E, é possível gravar a FPGA (e o chip de memória SPI que será mostrado adiante) pelo chip FTDI, que faz a ponte USB-Serial. E além disso, esse chip também permite criar um canal de comunicação diretamente Serial com a FPGA, para “brincar” com comunicação UART, por exemplo.

Detalhe FTDI

  • Conexão USB de 2 canais – usando FT2232D.
    • Canal A – JTAG – gravação da FPGA
    • Canal B – Comunicação Serial – UART

Spartan 3E FPGA

Essa é a estrela da placa.  O cérebro da Papilio One. No caso da Papilio One em questão, é uma FPGA com 250 mil portas lógicas, num equivalente a 5.508 elementos lógicos, o que é a “memória lógica” da FPGA, ou seja, determina o seu limite para incorporação de circuitos lógicos internos.

Hoje já existem FPGAs com muito, muito mais que 5 mil elementos lógicos de capacidade. Todavia, para um circuito extrapolar esse limite, é algo já bem complexo, acredite. E no espaço de lógica disponível da Papilio One, é possível “mimetizar” um Arduino, com mais recursos que um Arduino, somado ao programa em execução, etc.

Memória SPI Flash

Uma coisa que eu não falei anteriormente, é que as FPGAs possuem uma estrutura de retenção de configuração baseada em memórias RAM. E assim como as memórias RAM, essa estrutura é volátil, ou seja, quando o chip for desligado, a configuração gravada é perdida. Para que você não tenha que gravar o chip toda vez que ele for ligado, é necessário usar chips de memória em conjunto com FPGAs, o que é uma prática padrão no mercado. E a Papilio One segue essa mesma abordagem, possuindo uma memória SPI para gravação de dados da FPGA e de usuário.

Memória SPI

  • Memória Flash SPI de 4 Mbit para armazenar a configuração da FPGA – SST25VF040B .
  • Provê espaço para arquivo de configuração de FPGA (arquivos *.bit) e dados de usuário.
  • Qualquer arquivo *.bit escrito na SPI usando o Papilio Loader será automaticamente carregado quando a placa for energizada (modo bonito de falar “ligada”).
  • Dessa forma, a Spartan 3E carrega o programa da memória SPI embutida na Papilio One.

Wings – Os conectores laterais

O pessoal da Gadget Factory chama de “Wings” esses conectores que a Papilio (e demais irmãs) possuem.

  • São 48 sinais bidirecionais que podem ser divididos em:
    • 1 Wing de 32 bits
    • 3 Wings de 16 bits
    • 6 Wings de 8 bits

Em outras palavras, você configura os Wings como “registradores” de comunicação, podendo ter registradores de 32 bits, 16 bits ou 8 bits.

Blocos de I/O – Configuram as saídas dos Wings

Os blocos de I/O fornecem uma interface programável entre os pinos (dos Wings no caso da Papilio One) e a lógica interna da Spartan-3E.

  • Pull-up e Pull-Down programáveis, e resistores “flutuantes”. (Pull-Down por padrão em pinos não usados).
  • Atraso de entrada programável.
  • Limite de saída de corrente programável de 2 a 16 mA.
  • Todos os pinos de I/O são colocados em alta-impedância em modo de programação. Pinos não usados são colocados em pull-down por padrão pela ferramenta de desenvolvimento.

Bancos de I/O – Configuram as tensões de saída dos Wings

O jumper VCCO seleciona a tensão para todas as linhas de I/O,  e as opções são 1.2 V, 2.5 V e 3.3 V. A opção mais recomendada é a de 3.3 V, já que cada vez mais periféricos operam nessa tensão.

Blocos de Memória BRAM – “Blocos” de RAM para sua FPGA

A Spartan 3E também possui blocos de memória SRAM internos. No caso da Papilio One 250K, ela possui um máximo de 27 KBytes de SRAM, mas somente 24 KBytes são usáveis. Esses bancos de memória são úteis para serem usados como memórias adicionais em seus circuitos/sistemas. Do contrário, você teria que gastar aquela parcela de 5 mil elementos lógicos para criar memórias para seu circuito/sistema.

Compatível com Arduino IDE

O que permitiu a Papilio One ser compatível com o Arduino IDE é um “softcore” chamado ZPUino, que, para vocês terem noção da “potência”, é um processador de 32-bits operando a 96 MHz.

Um softcore é um processador desenvolvido para ser usado em lógica programável. Em outras palavras, assim como você carrega um programa no seu Arduino, você carrega um softcore na sua FPGA e ela passa a operar conforme aquele softcore.

A grande magia é que é um microprocessador genérico, criado por Álvaro Lopes e bem documentado na página do projeto ZPUino. Possui até mesmo todo um detalhado guia de usuário.

E assim como você consegue ver os fontes de programas abertos, há softcores abertos, como o caso do ZPUino, e você pode ver a estrutura dele no GitHub.

A IDE que você pode usar para programar o ZPUino com um programa à lá Arduino é o Design Lab IDE (neste mesmo link há a opção de download da ferramenta). E para desenvolver é simples: veja na figura abaixo a linha no topo do código – #define circuit ZPUino_Vanilla. Nessa linha eu determino que vou construir um código a ser usado nesse circuito-base, ZPUino.

Design Lab IDE
Figura – Desenvolvimento para Papilio One usando Arduino IDE.

E observem que o restante do código literalmente não difere em nada do que vocês vêem em Arduino.

Eu não sei vocês, mas num cenário assim a primeira pergunta que me vem à mente é: “E como eu uso os pinos da placa?!

Bom, para saber adequadamente quais pinos referenciar em seus programas Arduino (a.k.a. Sketchs), para a Papilio One basta consultar a referência de pinout da placa para ZPUino.

Observem na figura abaixo que há 6 marcações de bandas de sinais. Lembram que falei um pouco acima sobre como podemos operar os “Wings” da placa? Nessa figura é o destaque para 6 Wings de 8 bits cada.

Pinagem Papilio One
Figura – Numeração de referência para pinagem da Papilio One. Fonte: gadgetfactory.net

Ao clicar no famoso botão de “compilar e carregar” do DesignLab, a ferramenta irá fazer o seguinte:

  1. Manda um comando via USB-Serial para colocar a placa em modo de programação
  2. Irá sintetizar o ZPUino ou usar uma versão pré-configurada e sintetizada – sintetizar – criar o circuito.
  3. Irá compilar o seu Sketch criado no DesignLab para ZPUino.
  4. Irá juntar tudo e gravar na memória SPI da Papilio One.
  5. Mandará um comando de reset via USB-Serial e a placa será resetada
  6. No reset, a Spartan-3E vai “puxar” a lógica da memória SPI, e começará a operação do programa.
ZPUino com Papilio One. Fonte: http://papilio.cc/index.php?n=Papilio.ZPUinoIntroduction

Porém, se for pra usar “só assim”, não tem graça. A placa pode muito mais!
Mas para extrair os recursos a mais que ela oferece, é preciso descer no mundo dos circuitos programáveis.

Assim, torna-se possível modificar o ZPUino para ter mais portas seriais UART, mais timers, modular sinais VGA, etc, e usar esses recursos no seu programa.

Desenvolvimento com Xilinx ISE – Like a Boss

Em se tratando de FPGAs, ainda não há uma ferramenta universal ou amplamente utilizada entre fabricantes para desenvolvimento. Assim sendo, cada fabricante possui seu próprio ambiente de desenvolvimento.

Para a Xilinx, a fabricante dispõe de 2 ambientes de desenvolvimento: O Xilinx ISE Design Suite e o Xilinx Vivado Design Suite. A Xilinx ISE é para FPGAs até Spartan-6 e Virtex-6. Já a Vivado é para as FPGAs mais modernas.

No que tange à programação, para microcontroladores, você pode criar programas em C/C++, e hoje em dia é possível criar programas em Lua, Python, e outras linguagens mais. E para FPGAs?

FPGAs possuem as chamadas “linguagens de descrição”, pois você não programa o circuito, você “descreve” o circuito que será incorpordado, mimetizado na FPGA. E temos duas grandes linguagens para o mundo das FPGAs: Verilog e VHDL. E o uso dessas linguagens é igual torcida de futebol – há quem goste, quem critique, quem ame. Eu particularmente prefiro trabalhar com VHDL, e os fontes ZPUino estão em VHDL.

Dito e feito, para programar VHDL com a Papilio One, você irá precisar do Xilinx ISE Design Suite, e recomendo que seja a versão WebPack, gratuita, que você pode baixar neste link e procure por “Full Installer for Windows”.

Os mantenedores da Papilio também disponibilizam um guia para o setup do Xilinx ISE neste link.

Ficou curioso para saber como é a ferramenta com desenvolvimento em VHDL? Veja a figura adiante!

Desenvolvimento FPGA
Figura – Ambiente de Desenvolvimento Xilinx ISE. Fonte: gadgetfactory.net

Você pode programar a Papilio One totalmente com uma lógica sua, criada em VHDL pelo Xilinx ISE. Nesse caso, a ferramenta precisa ser informada dos sinais que serão usados para Entrada/Saída, e assim o mapa de sinais da placa segue a abordagem mostrada na Figura abaixo.

Figura – Mapa de Pinos em Modo FPGA – Papilio One.

Programação

A programação da Papilio One pode ser feita diretamente pelo DesignLab, quando você usa a ferramenta no “molde Arduino” (ou seja, todo o processo é feito automaticamente).

Porém, se você for desenvolver em mais baixo nível na placa, recorrendo ao Xilinx ISE Design Suite, tenha em mente o uso da ferramenta Papilio Loader (mencionada na parte de memória SPI).

A ferramenta é compatível com Windows e Linux, e você pode ver mais detalhes neste link. Para Windows, o download pode ser feito aqui.

Figura – Papilio Loader. Fonte: http://papilio.cc

A ferramenta Papilio Loader possui interface gráfica, mas também pode ser usada em linha de comando, o que auxilia atividades mais rotineiras e a criação de scritps para gravação da placa.

Agora, vamos aos arquivos usados para gravação da placa Papilio:

  • Arquivo .bit: É o bitstream que contém o softcore/softprocessador – Não programado!
  • Arquivo .bmm: É o mapa de blocos de memória, que descreve o layout de memória a ser usado pelo softcore referenciado pelo arquivo *.bit.  Esse arquivo é automaticamente gerado pela ferramenta de síntese FPGA (Xilinx ISE).
  • Arquivo .hex (ou .elf): E este, por final, é a aplicação para ZPUino compilada no DesignLab.

Caso você vá pura e simplesmente fazer um projeto de lógica digital em VHDL usando Xilinx ISE Design Suite, você só irá precisar do arquivo *.bit, que contém a lógica da coisa toda para FPGA.

Veja que no final do Tutorial de Xilinx ISE para Papilio há um detalhamento de onde você pode achar o arquivo *.bit gerado para o seu projeto, e assim utilizar esse arquivo na programação da placa Papilio.

Modo Analisador Lógico

A Papilio é um canivete suíço. Além de servir em uma infinidade de aplicações, ela também tem um modo de operação em que a placa se transforma em um analisador lógico de sinais!

Dessa forma, você pode usar a placa, e um programa instalado no PC, para verificar sinais de comunicação I2C, SPI, UART, sinais de controle Alto/Baixo, etc.

Mais detalhes desse modo, mostrado em operação na figura abaixo, pode ser visto neste link.

Figura – Usando a Papilio como analisador lógico. Fonte: https://www.youtube.com/watch?v=oI8R6AuokZU

Considerações Finais

A Papilio One é um canhão. Mais que um canhão, ela é um tanque. E como todo grande poder, demanda também grandes responsabilidades.

Digo isso para enfatizar que ela não é uma placa para iniciantes. Eu diria que é uma plataforma para pessoas de nível intermediário a avançado em sistemas embarcados, pessoas já acostumadas a ler documentação, acostumadas com esquemáticos elétricos e, principalmente, com programação.

Além disso, é imprescindível que você tenha noções de lógica digital e sistemas digitais, dado que em alguns momentos você poderá baixar no nível do circuito para criar sistemas mais personalizados com a sua Papilio One.

Falei bastante coisa, né? Espero que tenham gostado!

Gostou? Deixe seu comentário logo abaixo. Em caso de dúvidas, caso queira trocar uma ideia, ou até mesmo dividir seu projeto, acesse nosso Fórum!

Posts Relacionados

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *