VUnit 101: Guía práctica para verificación automatizada de VHDL

VUnit es un framework líder open‑source de verificación VHDL que acopla un runner de suite de tests Python con una librería VHDL dedicada. Juntos automatizan compilación de testbench, ejecución y reporte de resultados, permitiendo a ingenieros seguir un ciclo de desarrollo guiado por tests.

En este tutorial, Ahmadmunthar Zaklouta, autor detrás de VHDLwhiz, le guía a través de todo el flujo de trabajo VUnit —desde instalación y configuración hasta crear un testbench, escribir casos de test y ejecutarlos en ModelSim. Un proyecto de ejemplo listo para ejecutar está disponible para descarga.

Visión general

Use la barra lateral o el botón de navegación móvil para saltar entre secciones. El tutorial incluye capturas de pantalla para referencia visual.

Requisitos

• Intel ModelSim – Instalar gratis como se describe aquí. Añádalo a su PATH del sistema.
• Python 3.6+ – Descargar y añadir a PATH.
• Git (opcional) – Descargar.
• Windows Terminal (opcional) – Descargar.

Se asume competencia básica en VHDL y ModelSim.

Instalando VUnit

Clone el repositorio con submódulos:

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

O descargue el ZIP, extráigalo a C:\vunit, luego instale vía:

cd C:\vunit python setup.py install

Configure variables de entorno:

• VUNIT_MODELSIM_PATH – Ruta al ejecutable de ModelSim.
• VUNIT_SIMULATOR – Establecer a Modelsim.

Ejemplo de captura:

Descargar el proyecto de ejemplo

Extraiga el ZIP a C:\vunit_tutorial y ejecute los scripts incluidos.

Introducción a VUnit

VUnit simplifica la verificación HDL proporcionando:

• Una librería Python para automatización de tests, configuración y administración.
• Una librería VHDL con componentes de verificación reutilizables.

El lado VHDL incluye seis librerías; este tutorial se centra en las librerías logging y check.

Diseño bajo prueba (DUT)

El DUT de ejemplo, motor_start, controla tres LEDs (ROJO, AMARILLO, VERDE) para representar la secuencia de arranque de un motor. Su interfaz usa tipos record para entradas y salidas.

El proceso de arranque tiene tres pasos:

1. Carga de configuración (LED ROJO)
2. Calibración (LED AMARILLO)
3. Rotación (LED VERDE)

Secuencia de arranque

• LED ROJO – Parpadea cinco veces, luego permanece encendido.
• LED AMARILLO – Se enciende durante diez ciclos tras switch 2, luego se apaga con ROJO.
• LED VERDE – Se enciende mientras switch 3 está activo.

Desarrollo del testbench

1. Configurar el script Python run.py.
2. Construir el esqueleto VUnit.
3. Instanciar el DUT y conducir señales.

Script Python Run

El script run.py define rutas, crea una instancia VUnit y añade librerías de diseño y 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

En la entidad testbench, añadir el contexto VUnit y un generic obligatorio:

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;

La arquitectura aloja el proceso 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;

Los casos de test individuales se definen con bloques IF run("case_name") THEN.

Declaración de señales e instanciación del DUT

Definir relojes, resets y records de interfaz:

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;

Instanciar el 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 );

Conducir clock y reset:

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

Desarrollo de casos de test

Exploramos tres estilos de verificación: driver & checker inline, checker controlado y checker auto‑verificador.

Driver & Checker inline

Un caso de test simple que conduce switch_1 y verifica estados de LED usando la familia check de 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

Aquí el driver permanece en el caso de test mientras el checker corre en un proceso separado, controlado por eventos de inicio/fin. Por ejemplo, verificar el LED AMARILLO tras habilitar switch_2:

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‑verificador

Encapsular lógica de verificación en un proceso dedicado que usa check o check_stable internamente. Un procedimiento 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;

Ejecutando tests

Desde la terminal:

python .\run.py *switch_1_on_output_check

VUnit compila el diseño, descubre testbenches y ejecuta el caso especificado. La salida se registra en C:\vunit_tutorial\vunit_out\test_output.

Use -v para logs verbose, -l para listar todos los casos, --clean para purgar resultados previos, o -g para lanzar ModelSim con ventana de ondas (requiere archivo wave.do).

Resumen

VUnit ofrece un framework robusto y ligero que acelera tanto a equipos de diseño como de verificación. Su harness de tests impulsado por Python, ricas librerías VHDL y API de checker flexible lo convierten en una adición valiosa a cualquier flujo de trabajo HDL.

Próximos pasos

• Lea la documentación oficial.
• Siga el blog de VUnit para actualizaciones.
• Únase a la comunidad en Gitter.

Descargue el proyecto de ejemplo completo vía el formulario abajo.