Aprimorando a Verificação de Hardware com Testbench Interativo Baseado em Tcl

Um testbench interativo é uma configuração de simulador onde a entrada para o device under test (DUT) é fornecida por um operador enquanto o testbench está em execução. Na maioria das vezes, isso significa inserir comandos no console do simulador para fornecer estímulos ao DUT.

Embora você deva sempre criar um testbench de auto-verificação, um testbench interativo pode ser um bom complemento. É mais fácil realizar testes ad-hoc com um testbench interativo à mão do que alterar o código do testbench de auto-verificação.

Muitas vezes, você descobrirá problemas no laboratório que desejará testar no testbench. Com um testbench interativo, pode ser tão fácil quanto digitar a sequência de entrada observada para replicar o comportamento indesejado no simulador.

Tcl interagindo com VHDL

A maioria dos simuladores VHDL usa Tcl como linguagem de console. Os simuladores têm vários comandos específicos do fornecedor, mas a boa notícia é que eles podem ser tratados como qualquer outro comando Tcl. Você pode usar Tcl para criar scripts complexos, principalmente portáteis, para gerenciar e dar suporte aos seus testbenches VHDL.

Alterando sinais VHDL a partir do Tcl

Para interagir com VHDL, precisamos encontrar o comando para alterar o valor de um sinal. No ModelSim, este é o comando "force". Conforme especificado no documento de referência de comandos, a sinopse para o comando é:

force {<object_name> <value> [[@]<time_info>][, <value> [@]<time_info>]... [-deposit | -drive | -freeze] [-cancel [@]<time_info>] [-repeat [@]<time_info>]

A chave que você deseja usar é a flag "-deposit". Isso altera o valor do sinal VHDL instantaneamente, mas permite que outro driver VHDL ou Tcl o altere para algo diferente em um momento posterior.

Ignorando as opções que não estamos usando, a sinopse simplificada fica assim:

force -deposit <signal_name> <value>

O gatilho VHDL

Agora que sabemos como controlar sinais VHDL a partir do Tcl, precisamos criar algum tipo de processo receptor no nosso testbench VHDL. O código abaixo mostra um exemplo mínimo de tal testbench.

 library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity interactive is end interactive; architecture sim of interactive is -- Controlado por Tcl signal trigger : std_logic := '0'; begin process is begin wait until trigger = '1'; report "Triggered!"; end process; end architecture; 

O processo acordará quando o sinal trigger mudar de algo para '1'. Ele imprimirá "Triggered!" no console quando isso acontecer, permitindo-nos testar o conceito de controlar processos VHDL a partir do Tcl.

Fiz exatamente isso no console do ModelSim. Os comandos emitidos, bem como a saída, podem ser vistos no transcript abaixo.

VSIM 1> run 10 ns; VSIM 2> force -deposit /trigger '1' VSIM 3> run 0 ns; # ** Note: Triggered! # Time: 10 ns Iteration: 0 Instance: /interactive VSIM 4> force -deposit /trigger '0' VSIM 5> run 10 ns;

Executei o testbench por 10 nanossegundos após iniciar a simulação.

Então, forcei o sinal trigger para '1'. Na próxima linha, esperei 0 nanossegundos. O propósito disso é criar um delta cycle. Quero que o processo seja disparado, mas não quero que nenhum tempo de simulação passe.

Finalmente, forcei o sinal trigger de volta para '0' antes de continuar o testbench.

Podemos ver que o processo VHDL acordou após a linha "run 0 ns" e imprimiu "Triggered!" no console.

Lendo valores de sinais VHDL no Tcl

Para ler valores de sinais no ModelSim, você pode usar o comando "examine". Podemos, por exemplo, ler o valor do sinal trigger usando este comando no console do ModelSim:

VSIM 6> examine /trigger # 0

Você gostaria de atribuir o valor a uma variável Tcl ao usar "examine" em um script. Vamos tentar isso no console do ModelSim:

VSIM 7> set triggerVal [examine /trigger] # 0

Então podemos, por exemplo, imprimir a variável usando o comando Tcl "puts":

VSIM 8> puts "triggerVal: $triggerVal" # triggerVal: 0

Parando o simulador após cada teste

A maneira mais fácil de executar o teste tempo suficiente para o DUT reagir é simplesmente rodar o simulador por um valor de tempo fixo. Por exemplo, se o DUT deve reagir após dois ciclos de clock, e o período do clock é 10 nanossegundos, usaríamos o comando "run 20 ns" no nosso script Tcl.

Se o DUT não tem um tempo de reação fixo, uma asserção VHDL pode ser usada para parar a simulação e passar o controle para uma função de callback Tcl. No ModelSim, isso significaria definir um breakpoint a partir do seu script Tcl usando o comando "when":

when [[-fast] [-id <id#>] [-label <label>] {<when_condition_expression>} {<command>}]

Você também teria que definir uma função de callback "onBreak" em Tcl que será executada quando o breakpoint for atingido. A função "onBreak" é especificada na referência de comandos do ModelSim.

As desvantagens de testes dirigidos por Tcl

Existem desvantagens em usar testbenches que dependem fortemente de scripts Tcl. As mais aparentes são os problemas de velocidade e portabilidade.

Testbenches dirigidos por Tcl funcionam iniciando e parando o simulador múltiplas vezes para interagir com o código VHDL. Iniciar e parar a simulação para executar uma função Tcl no meio é mais demorado do que rodar um testbench VHDL continuamente. Enquanto Tcl é uma linguagem interpretada, VHDL é compilado no simulador e roda muito mais rápido que Tcl.

Embora Tcl seja portável para outros simuladores, os comandos específicos do simulador que você terá que usar não são. Mesmo que você encontre os comandos equivalentes no outro simulador, eles podem funcionar de forma diferente. Fornecedores de simuladores criam seu próprio conjunto de regras para os comandos que suportam. Portanto, um testbench dirigido por Tcl deve ser considerado menos portável que um testbench VHDL puro.

Novo curso de VHDL e FPGA

* Estou criando um novo curso de VHDL e FPGA que mergulhará extensivamente em testbenches. Você aprenderá como criar um design FPGA do zero. Após completar o curso, você saberá como criar testbenches de auto-verificação e como reutilizar o código para criar um testbench interativo.

* Atualizado em 12 de outubro de 2020: Completei o curso. Clique na imagem abaixo para saber mais.

O produto que criaremos é um módulo controlador de LED de matriz de pontos. Usaremos a placa de desenvolvimento Lattice iCEstick de $49. No final, implementaremos o design em uma protoboard. Você poderá digitar no teclado do seu computador, e os caracteres aparecerão na tela de LED de matriz de pontos controlada pelo FPGA.

Saiba mais sobre o curso VHDL e FPGA de Matriz de Pontos aqui!

Início:

A ser decidido.