Arduino como um FPGA de placa de ensaio barato: 5 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Projetar circuitos lógicos de hardware pode ser divertido. A maneira tradicional de fazer isso era com portas NAND, em uma placa de ensaio, conectadas com fios de jumper. Isso ainda é possível, mas não demora muito para que o número de portas saia do controle. Uma opção mais recente é usar um FPGA (Field Programmable Gate Array). Esses chips podem se reconectar para se tornarem qualquer circuito lógico digital que você possa projetar, mas não são baratos e prontamente disponíveis. Vou mostrar como este FPGA pode ser substituído por um chip Atmega barato de um Arduino UNO, efetivamente colocando o circuito digital em um pacote DIP, que é muito amigável para protoboard.

Etapa 1: Projete o circuito que o "FPGA" representará

Vou construir um somador de 2 bits + 2 bits. Leva dois pares de pinos de entrada lógica e produz um tripleto de pinos de saída.

Para fazer isso com portas NAND, consulte o esquema na imagem. Precisa de 14 portas NAND. Usei 4 chips TTL de 4 portas NAND e conectei-os à placa de pão.

Eu adicionei alguns LEDs (não se esqueça dos resistores limitadores de corrente) para mostrar quando os pinos de entrada e saída estavam ligados (alto) e quando estavam desligados (baixo). Para acionar os pinos de entrada, eu os conectei ao trilho de aterramento ou ao trilho de alimentação positivo.

Este circuito funciona, mas já ocupa 4 chips TTL e é um ninho de ratos de fios. Se mais bits fossem necessários, haveria mais placas de pão e mais jumpers. Muito rapidamente, o tamanho do circuito sairia do controle.

Por outro lado, ao trabalhar com portas TTL, elas não produzem exatamente 0 V ou 5 V como seria de se esperar. Eles geralmente produzem em torno de 3 V para "alta", mas a tensão exata está em uma faixa muito ampla. O mesmo circuito usando os chips equivalentes CMOS teria melhor oscilações de exatamente 0V a exatamente 5V.

Etapa 2: Entre no FPGA

Um FPGA é um chip fantástico, que pode literalmente se tornar qualquer combinação de portas lógicas, conectadas em qualquer combinação. Um projeta o "circuito" em uma linguagem de design de hardware (HDL). Existem vários desses idiomas, um dos quais é chamado Verilog. O arquivo.v na imagem é o equivalente em Verilog do somador de dois bits. O arquivo.pch abaixo também é necessário para atribuir os pinos de entrada e saída nomeados no arquivo verilog para pinos de hardware reais no chip.

Neste caso, estou usando uma placa de desenvolvimento iCEstick da Lattice Semiconductors (https://www.latticesemi.com/icestick). O chip FPGA real é um iCE40HX-1k, com um pouco mais de 1000 portas, que podem se tornar qualquer porta lógica. Isso significa que cada porta pode ser uma porta NAND ou uma porta OR, porta NÃO, NOR, XOR, etc. Além disso, cada porta pode lidar com mais de duas entradas. Isso é específico para cada fabricante, mas no iCE40 cada porta pode lidar com 4 entradas. Assim, cada porta é muito mais capaz do que as 2 portas NAND de entrada.

Tive de atribuir os 4 pinos de entrada e os 3 pinos de saída aos pinos físicos 91, 90, 88, 87, 81, 80 e 79, respectivamente. Isso é específico para o chip fpga e a placa de breakout em que está instalado e como esses pinos são conectados à porta PMOD. Isso está disponível nas planilhas de dados desta placa FPGA.

O Lattice fornece sua própria cadeia de ferramentas para sintetizar (o FPGA equivalente à compilação para CPUs) circuitos da Verilog, mas usei a cadeia de ferramentas de código aberto livre icestorm (https://www.clifford.at/icestorm/). As instruções de instalação estão disponíveis nesse site. Com o icestorm instalado e os arquivos verilog e pcf, os comandos para carregar este circuito no FPGA são:

yosys -p "synth_ice40 -blif twoBitAdder.v" twoBitAdder.blif

arachne-pnr -d 1k -p iCEstick.pcf twoBitAdder.blif -o twoBitAdder.asc

icepack twoBitAdder.asc twoBitAdder.bin

iceprog twoBitAdder.bin

Isso funciona muito bem, mas incluindo o envio deste iCEstick custará cerca de US $ 30. Esta não é a maneira mais barata de construir um circuito digital, mas é poderosa. Tem mais de 1000 portas e para este minúsculo circuito usa apenas 3 delas. O equivalente de porta NAND usava 14 portas. Isso se deve ao fato de que cada porta pode se tornar qualquer tipo de porta, e cada porta é na verdade uma porta de 4 entradas. Cada portão pode fazer mais. Se você precisar de mais portas, o iCEstick tem um irmão maior com 8.000 portas, que custa cerca do dobro. Outros fabricantes têm outras ofertas, mas o preço pode ficar bem alto.

Etapa 3: do FPGA para o Arduino

FPGAs são ótimos, mas podem ser caros, difíceis de encontrar e não são muito amigáveis. Um chip amigável e barato de breadboard é o Atmega 328 P, que vem em um pacote DIP bacana, perfeito para breadboard. Também pode ser adquirido por cerca de $ 4. Este é o coração do Arduino UNO. É claro que você poderia usar o UNO inteiro, mas seja barato, podemos retirar o Atmega 328 P do UNO e usá-lo sozinho. No entanto, usei a placa UNO como programador para o Atmega.

Neste ponto, você precisará

1. Um Arduino UNO, com a CPU Atmega 328P removível.

2. Outro Atmega 328P com o bootloader Arduino pré-queimado, para substituir o que estamos prestes a retirar do UNO. (Opcional, supondo que você ainda deseja ter um UNO utilizável).

O objetivo é converter o arquivo verilog em um projeto arduino que pode ser carregado no 328P. Arduino é baseado em C ++. Convenientemente, há um tradutor de Verilog para C ++, chamado Verilator (https://www.veripool.org/wiki/verilator). O Verilator deve ser usado por designers de hardware que precisam simular seus designs antes de comprometer esses designs com hardware caro. O Verilator compila o verilog para C ++ e, em seguida, o usuário fornece um equipamento de teste para fornecer sinais de entrada simulados e registrar os sinais de saída. Vamos usá-lo para enfiar o design verilog no Atmega 328P usando a cadeia de ferramentas Arduino.

Primeiro instale o Verilator. Siga as instruções em

Instale também o Arduino IDE e teste se ele pode se conectar ao Arduino UNO por USB.

Estaremos usando o mesmo arquivo verilog do FPGA, exceto que os nomes dos pinos precisam ser alterados. Eu adicionei um sublinhado (_) no início de cada um. Isso é necessário porque as bibliotecas do arduino incluem um arquivo de cabeçalho que traduz coisas como B0, B001, etc, para números binários. Os outros nomes de pinos de entrada estariam bem no estado em que se encontravam, mas B0 e B1 teriam causado a falha da compilação.

No diretório que contém twoBitAdder.v e iCEstick.pcf, execute o seguinte:

verilator -Wall --cc twoBitAdder.v

Isso criará um subdiretório chamado obj_dir contendo vários arquivos novos. Precisamos apenas dos arquivos de cabeçalho e cpp, VtwoBitAdder.h, VtwoBitAdder.cpp, VtwoBitAdder_Syms.h e VtwoBitAdder_Syms.cpp.

No IDE do Arduino, crie um novo esboço chamado twoBitAdder.ino. Isso criará o arquivo ino em um novo diretório também chamado twoBitAdder, dentro do diretório do caderno de desenho do Arduino. Copie seus arquivos VtwoBitAdder.h e VtwoBitAdder.cpp para esta pasta twoBitAdder em sua pasta Arduino.

Agora copie os arquivos de cabeçalho da instalação do verilator.

cp / usr / local / share / verilator / include / verilated *.

finalmente copie na biblioteca std c ++ em https://github.com/maniacbug/StandardCplusplus. De acordo com as instruções de instalação Isto é instalado como uma biblioteca Arduino normal. Descompacte o conteúdo da distribuição na pasta 'bibliotecas' em seu bloco de desenho. Por exemplo, meu bloco de desenho está em / home / maniacbug / Source / Arduino, então esta biblioteca está em / home / maniacbug / Source / Arduino / libraries / StandardCplusplus.

Certifique-se de redefinir o IDE do Arduino após instalá-lo."

Agora substitua o conteúdo de twoBitAdder.ino pelo fornecido nesta etapa. Este é um equipamento de teste que o verilator espera, que configura os pinos de entrada / saída, então no loop, lê os pinos de entrada, os alimenta para o VtwoBitAdder (a versão traduzida do nosso circuito), então lê as saídas do VtwoBitAdder e aplica para os pinos de saída.

Este programa deve ser compilado e executado no Arduino UNO.

Etapa 4: do Arduino ao chip DIP em uma placa de pão

Agora que o programa está sendo executado no Arduino, não precisamos mais da própria placa do Arduino. Tudo que precisamos é a CPU.

Remova o Atmega 328P cuidadosamente do soquete Arduino UNO e, opcionalmente, insira seu substituto.

Coloque o Atmega 328P na placa de ensaio. Coloque a ponta com o divot apontando para cima na tábua do pão. O pino 1 é o pino superior esquerdo. O pino 2 é o próximo para baixo, e assim por diante até o pino 14, que está na parte inferior esquerda. Em seguida, o pino 15 está no canto inferior direito e os pinos 16 a 28 contam de volta para o lado direito do chip.

Conecte os pinos 8 e 22 ao aterramento.

Conecte o pino 7 ao VCC (+ 5V).

Conecte um cristal de quartzo de 16 MHz entre os pinos 9 e 10. Também um pequeno capacitor (22pF) entre o pino 9 e o terra e entre o pino 10 e o terra. Isso dá ao Atmega 328P a velocidade de clock de 16 MHz. Existem instruções em outro lugar sobre como ensinar o 328P a usar seu clock interno de 8 MHz, o que economizaria algumas partes, mas tornaria o processador lento.

As portas 5, 6, 7 e 8 do Arduino GPIO, que usamos para os pinos de entrada, são na verdade os pinos físicos 11, 12, 13, 14 no Atmega 328P. Esses seriam os quatro pinos inferiores à esquerda.

As portas Arduino GPIO 11, 10 e 9, que usamos para os pinos de saída, são na verdade os pinos físicos 17, 16, 15 no Atmega 328P. Esses seriam os três pinos inferiores à direita.

Liguei os LEDs a esses pinos como antes.

Etapa 5: Conclusão

Os chips TTL funcionam, mas são necessários muitos para construir qualquer coisa. FPGAs funcionam muito bem, mas não são baratos. Se você pode viver com menos pinos de IO e velocidade mais baixa, então um Atmega 328P pode ser o chip para você.

Algumas coisas para ter em mente:

FPGA:

Pró

- Pode lidar com sinais de alta velocidade. Como não há CPU para impedir o processamento de uma instrução por vez, o fator limitante é o atraso de propagação através das portas no circuito fornecido. Em muitos casos, isso pode ser muito mais rápido do que o relógio fornecido com o chip. Para o meu projeto, o atraso computado teria permitido que o twoBitAdder respondesse a cerca de 100 milhões de mudanças nos valores de entrada por segundo (100Mhz), embora o relógio on-board seja apenas um cristal de 12Mhz.

- Conforme o projeto fica mais complexo, o desempenho dos circuitos existentes não se degrada (muito). Como adicionar circuitos ao tecido é simplesmente colocar algo novo em um espaço não utilizado, isso não afeta os circuitos existentes.

- Dependendo do FPGA, o número de pinos de E / S disponíveis pode ser muito alto e, geralmente, eles não estão bloqueados para uma finalidade específica.

Vigarista

- Pode ser caro e / ou difícil de encontrar.

- Normalmente vem em um pacote BGA que requer algum tipo de placa breakout para funcionar com o chip em qualquer projeto amador. Se você estiver criando um design com uma SMT PCB multicamada personalizada, isso não é um problema.

- A maioria dos fabricantes de FPGAs fornece seu próprio software de design de código-fonte fechado, que em alguns casos pode custar dinheiro ou ter uma licença com data de expiração.

Arduino como FPGA:

Pró

- Barato e fácil de obter. Basta pesquisar atmega328p-pu na Amazon. Eles devem custar cerca de US $ 4 / peça. Vários vendedores os vendem em lotes de 3 ou 4.

- Este é um pacote DIP, o que significa que se encaixa perfeitamente em uma placa de ensaio com seus pinos externos.

- Este é um dispositivo de 5V, que pode facilitar a interface com outros dispositivos de 5V.

Vigarista

- O ATMEGA328P tem um número limitado de pinos IO (23), e vários deles são reservados para tarefas específicas.

- Conforme a complexidade do circuito aumenta, a quantidade de código executado no método de loop do Arduino aumenta, o que significa que a duração de cada ciclo é maior.

- Mesmo se a complexidade do circuito for baixa, cada ciclo requer muitas instruções da CPU para buscar os valores dos pinos de entrada e escrever os valores dos pinos de saída e retornar ao topo do loop. Com um cristal de 16 MHz, mesmo com uma instrução por ciclo de clock, o loop não será executado mais do que talvez 1 milhão de vezes por segundo (1 MHz). Para a maioria dos projetos de eletrônicos amadores, isso é muito mais rápido do que o necessário.