VUnit 101: Guia Prático para Verificação Automatizada de VHDL

VUnit é um framework líder open-source de verificação VHDL que acopla um executor de suíte de testes Python com uma biblioteca VHDL dedicada. Juntos eles automatizam compilação de testbench, execução e relatório de resultados, permitindo que engenheiros sigam um ciclo de desenvolvimento orientado a testes.

Neste tutorial, Ahmadmunthar Zaklouta, autor por trás do VHDLwhiz, guia você por todo fluxo de trabalho VUnit — da instalação e configuração à criação de testbench, escrita de casos de teste e execução no ModelSim. Um projeto de exemplo pronto para rodar está disponível para download.

Visão Geral

Use a barra lateral ou botão de navegação móvel para pular entre seções. O tutorial inclui capturas de tela para referência visual.

Requisitos

• Intel ModelSim – Instale gratuitamente conforme descrito aqui. Adicione ao PATH do sistema.
• Python 3.6+ – Baixe e adicione ao PATH.
• Git (opcional) – Baixe.
• Windows Terminal (opcional) – Baixe.

Proficiência básica em VHDL e ModelSim é assumida.

Instalando VUnit

Clone o repositório com submódulos:

git clone --recurse-submodules https://github.com/VUnit/vunit.git

Ou baixe o ZIP, extraia para C:\vunit, então instale via:

cd C:\vunit python setup.py install

Configure variáveis de ambiente:

• VUNIT_MODELSIM_PATH – Caminho para o executável ModelSim.
• VUNIT_SIMULATOR – Defina como Modelsim.

Exemplo de screenshot:

Baixe o Projeto Exemplo

Extraia o ZIP para C:\vunit_tutorial e execute os scripts incluídos.

Introdução ao VUnit

VUnit simplifica verificação HDL fornecendo:

• Biblioteca Python para automação de testes, configuração e administração.
• Biblioteca VHDL contendo componentes de verificação reutilizáveis.

O lado VHDL inclui seis bibliotecas; este tutorial foca nas bibliotecas logging e check.

Design Sob Teste (DUT)

O DUT de exemplo, motor_start, aciona três LEDs (VERMELHO, AMARELO, VERDE) para representar sequência de inicialização de motor. Sua interface usa tipos record para entradas e saídas.

O processo de inicialização tem três passos:

1. Carregamento de configuração (LED VERMELHO)
2. Calibração (LED AMARELO)
3. Rotação (LED VERDE)

Sequência de Inicialização

• LED VERMELHO — Pisca cinco vezes, depois permanece aceso.
• LED AMARELO — Liga por dez ciclos após switch 2, depois desliga com VERMELHO.
• LED VERDE — Acende enquanto switch 3 está ativo.

Desenvolvimento do Testbench

1. Configure o script Python run.py.
2. Construa o esqueleto VUnit.
3. Instancie o DUT e acione sinais.

Script Python Run

O script run.py define caminhos, cria instância VUnit e adiciona bibliotecas de design e testbench:

# ROOT directory ROOT = Path(__file__).resolve().parent # Source paths DUT_PATH = ROOT / "design" TEST_PATH = ROOT / "testbench" # VUnit instance VU = VUnit.from_argv() VU.enable_location_preprocessing() # Libraries design_lib = VU.add_library("design_lib") design_lib.add_source_files([DUT_PATH / "*.vhdl"]) tb_lib = VU.add_library("tb_lib") tb_lib.add_source_files([TEST_PATH / "*.vhdl"])

Esqueleto VUnit

Na entidade testbench, adicione contexto VUnit e generic obrigatório:

LIBRARY VUNIT_LIB; CONTEXT VUNIT_LIB.VUNIT_CONTEXT; ENTITY motor_start_tb IS GENERIC(runner_cfg : string := runner_cfg_default); END ENTITY motor_start_tb;

A arquitetura hospeda o processo test runner:

ARCHITECTURE tb OF motor_start_tb IS test_runner : PROCESS BEGIN test_runner_setup(runner, runner_cfg); WHILE test_suite LOOP -- test cases END LOOP; test_runner_cleanup(runner); END PROCESS; END ARCHITECTURE;

Casos de teste individuais são definidos com blocos IF run("case_name") THEN.

Declaração de Sinais & Instanciação do DUT

Defina clocks, resets e records de interface:

CONSTANT C_CLK_PERIOD : time := 10 ns; SIGNAL clk, reset : STD_LOGIC := '0'; SIGNAL motor_start_in : MOTOR_START_IN_RECORD_TYPE := (switch_1 => '0', switch_2 => '0', switch_3 => '0'); SIGNAL motor_start_out : MOTOR_START_OUT_RECORD_TYPE;

Instancie o DUT:

motor_start_tb_inst : ENTITY DESIGN_LIB.motor_start(rtl) PORT MAP( clk => clk, reset => reset, motor_start_in => motor_start_in, motor_start_out => motor_start_out );

Acione clock e reset:

clk <= NOT clk after C_CLK_PERIOD / 2; reset <= '0' after 5 * (C_CLK_PERIOD / 2);

Desenvolvimento de Casos de Teste

Exploramos três estilos de verificação: driver & checker inline, checker controlado, e checker auto-verificável.

Driver & Checker Inline

Um caso de teste simples que aciona switch_1 e verifica estados dos LED usando família check do VUnit:

IF run("switch_1_on_output_check") THEN WAIT UNTIL reset = '0'; WAIT UNTIL falling_edge(clk); motor_start_in.switch_1 <= '1'; FOR i IN 0 TO 4 LOOP WAIT UNTIL rising_edge(clk); check(motor_start_out.red_led = '1', "Red LED should be on"); check_false(motor_start_out.yellow_led, "Yellow LED should be off"); check_equal(motor_start_out.green_led, '0', "Green LED should be off"); END LOOP; END IF;

Checker Controlado

Aqui o driver permanece no caso de teste enquanto o checker roda em processo separado, controlado por eventos start/end. Por exemplo, verificando LED AMARELO após switch_2 ser habilitado:

check_stable(clock => clk, en => enable, start_event => yellow_low_start_event, end_event => yellow_low_end_event, expr => motor_start_out.yellow_led, msg => "YELLOW LED low before switch_2");

Checker Auto-Verificável

Encapsule lógica de verificação em processo dedicado que usa check ou check_stable internamente. Um procedimento driver simplifica estímulo:

PROCEDURE switch_driver( SIGNAL switches : OUT MOTOR_START_IN_RECORD_TYPE; CONSTANT clk_period : IN TIME; CONSTANT sw1_delay : IN INTEGER; CONSTANT sw2_delay : IN INTEGER; CONSTANT sw3_delay : IN INTEGER) IS BEGIN IF sw1_delay >= 0 THEN WAIT FOR clk_period * sw1_delay; switches.switch_1 <= '1'; END IF; IF sw2_delay >= 0 THEN WAIT FOR clk_period * sw2_delay; switches.switch_2 <= '1'; END IF; IF sw3_delay >= 0 THEN WAIT FOR clk_period * sw3_delay; switches.switch_3 <= '1'; END IF; END PROCEDURE;

Executando Testes

Do terminal:

python .\run.py *switch_1_on_output_check

VUnit compila o design, descobre testbenches e executa o caso especificado. Saída é logada em C:\vunit_tutorial\vunit_out\test_output.

Use -v para logs verbosos, -l para listar todos casos, --clean para limpar resultados anteriores, ou -g para lançar ModelSim com janela de waveform (requer arquivo wave.do).

Resumo

VUnit oferece framework robusto, leve que acelera tanto equipes de design quanto verificação. Seu harness de testes Python-driven, ricas bibliotecas VHDL e API flexível de checker tornam-no adição valiosa a qualquer fluxo HDL.

Próximos Passos

• Leia a documentação oficial.
• Siga o blog VUnit para atualizações.
• Junte-se à comunidade no Gitter.

Baixe o projeto de exemplo completo via formulário abaixo.