Simulando o projeto FPGA sem o hardware real

Eu sou novo no FPGA e atualmente estou na classe HDL (Verilog particularmente). Tenho conhecimento suficiente em design digital, como circuitos combinacionais e seqüenciais.

Quero criar um projeto semelhante ao mostrado neste vídeo do YouTube .

Sei também que o Xilinx ISE pode processar sinais lógicos e simular formas de onda. Possui capacidade extra, como obter os sinais de entrada via USB, câmera etc. e enviá-los para o seu computador.

É possível executar este projeto (como uma simulação em computador) sem comprar uma placa FPGA real? O que quero dizer é: posso criar, codificar e executar esse projeto no meu computador e conectar minha câmera via USB e deixar que os sinais de vídeo recebidos sejam processados ​​por simuladores HDL como o Xilinx ISE etc. (sem comprar realmente um quadro FPGA e sintetizar seu projeto lá, atualmente não tenho orçamento para ter um)

(O que realmente quero dizer é conectar o design do HDLl a fontes do mundo real, código C etc.)

As ferramentas Xilinx não podem interagir em tempo real, tanto quanto eu sei, nem o ModelSim (usado pelo Libero IDE da Actel).
Eu não sei sobre simuladores de código aberto, existem alguns projetos bastante exóticos por aí, então é possível que exista. algo que poderia fazer isso.

No entanto, essa pode ser uma resposta que você não solicitou (eu a excluirei, se não for útil), mas consideraria criar sua própria placa FPGA para fazer isso ou, pelo menos, começar o processo. Eu gravei minha primeira placa FPGA e, embora fosse muito simples (a placa não é o processo ;-)), ela me ensinou muito rapidamente.

Prós:

• Barato
• Vá direto ao fundo e aprenda tudo o que você precisa saber sobre as considerações de hardware. Obriga você a ler a maioria das planilhas de dados primeiro e a escrever seu próprio código inicial, que IMHO geralmente é melhor do que a abordagem plug-and-play do aprendizado de placa de desenvolvimento.
• Coloque apenas no quadro o que você precisa.
• Você vai mais longe em direção ao seu objetivo de um projeto de trabalho real, possivelmente com o mesmo esforço / pesquisa que descobrir como simular tudo em tempo real.

Contras:

• Ainda é necessário comprar um programador, embora as versões baratas dos programadores Xilinx / Altera possam ser encontradas no eBay.
• Se o design e os problemas da integridade da placa de circuito impresso / sinal não são algo em que você deseja se concentrar, talvez você não esteja interessado em grande parte do conhecimento a ser obtido dessa maneira.

Entendo que a gravação da sua própria placa provavelmente não é necessária, apenas fiz porque tinha os FPGAs lá, estava impaciente e não queria esperar duas semanas para a chegada de um PCB. Existem ofertas extremamente baratas aqui para placas de duas camadas, o que faria pelo menos para executar seu design (possivelmente a velocidades mais baixas do que o desejado) - normalmente a contagem mínima de camadas para um design FPGA de alta velocidade seria 4, mas essas são Muito mais caro)

De qualquer forma, a Spirit Circuits faz um negócio totalmente gratuito de PCB de "camada simples" de duas camadas (uma por mês, um design, sem máscara ou serigrafia) que é útil para um design único.
Além disso, para placas de protótipo baratas adequadas de 2 e 4 camadas, o ITead e o Seed Studio chegam a US $ 10 por serviços de 10 placas (ou possivelmente 5 por esse preço).

O Xilinx ISE Webpack padrão (a versão gratuita que você pode baixar no xilinx.com) inclui um simulador chamado iSim. Não é um ótimo simulador, mas é totalmente funcional e o preço é justo.

Embora eu não tenha usado as ferramentas Altera, me surpreenderia se um simulador não fosse incluído.

Mas ... Você precisa saber o que um simulador pode ou não fazer. Para iniciantes, ele não pode simular um FPGA rodando a toda velocidade. De fato, eles são bastante lentos. Dependendo da complexidade do FPGA sendo simulado, não seria de surpreender que levasse 1 minuto para simular 1 ms de "tempo simulado". Se você deseja simular uma hora de "tempo simulado", isso exigiria 1000 horas de tempo real.

Além disso, um FPGA simulado não pode se comunicar diretamente com coisas como sua porta USB. O FPGA simulado se comunica com um "testbench". O testbench é um pedaço do código VHDL ou Verilog que alimenta as entradas do FPGA (ou partes do FPGA) e verifica a saída do seu FPGA. Você pode fazer algumas coisas bastante complexas em um ambiente de teste, como usar números de ponto flutuante, ler e gravar arquivos e executar uma lógica que é impossível de sintetizar.

Não conheço nenhum simulador que faça interface direta com os sinais que chegam a uma porta USB (ou outro hardware).

Pelo menos em teoria, seria possível escrever algum software que pegasse sinais que chegassem a uma porta e os convertesse em um arquivo testbench que um simulador poderia processar. Infelizmente, eu não conheço nenhum software existente para fazer isso, e escrevê-lo você mesmo seria decididamente não trivial.

Você precisará usar interfaces de co-simulação (DPI, VPI, VHPI, FLI) que permitem escrever código que se conecta ao simulador e, assim, conectar a RTL em simulação e o hardware real em sua máquina.

Os problemas significativos que você encontrará (além de interfaces mal documentadas) estão relacionados à sincronização e ao tempo. A execução de RTL na simulação é muito mais lenta que o hardware real - você precisará passar pelas interações com a interface externa para corresponder à velocidade da simulação. Algumas interfaces de hardware não serão assim! Por exemplo, se você estiver usando o TCP, poderá ser necessário alterar os temporizadores na pilha do kernel para evitar retransmissões espúrias, etc.

O Icarus suporta o VPI e é gratuito, para que você possa experimentar sem gastar dinheiro com licenças. Você pode querer examinar estruturas existentes que realizam parte do trabalho pesado de co-simulação e fornecem uma abstração mais limpa ao simulador. Um desses frameworks é o Cocotb , uma biblioteca de código aberto que fornece uma interface Python para o simulador. ( Aviso: sou um dos desenvolvedores do cocotb.)

Um exemplo que pode ser relevante: ontem, liguei para um RTL para responder às solicitações de ping e criei um testbench que abre uma interface TUN. Em seguida, você pode pingexecutar ping na interface usando o comando e o RTL em execução recebe o ping e responde. Todo o testbench tem menos de 50 linhas de Python! O código fonte deste exemplo está no Github e é executado no Icarus no Linux.

Na grande maioria dos casos, tudo o que você faz na simulação permanece na simulação. Você não pode acessar o hardware real a partir dele - você precisa ter um modelo de simulação do hardware real.

No entanto, se você estiver disposto a fazer algum esforço, a maioria dos simuladores possui uma interface para código arbitrário. No Verilog, como eu a entendo, é uma interface bastante padrão; portanto, o lado do Verilog é portado entre os simuladores. Na região VHDL, existe uma maneira padrão de fazê-lo, mas pelo menos um dos grandes fornecedores tem sua própria maneira de fazê-lo!

Lembre-se também de que a interface em tempo real (ou seja, na velocidade que o FPGA o faria) é muito improvável - e o restante da sua simulação (o HDL) também não será executado em tempo real. Conforme observado nos comentários, o processamento simulado em tempo real de vídeo não é viável dessa maneira.

Pessoalmente, nunca precisei tentar isso, acho que sou mais produtivo escrevendo modelos de hardware e executando tudo em VHDL.

Mas não negligencie os benefícios de fazer a simulação - é uma maneira muito mais rápida de descobrir se as coisas estão funcionando (compilações levam segundos) e depois construir fluxos de bits (compilações levam dezenas de minutos a horas) e testá-las em hardware.