Caso práctico: Barras de color VGA 640×480 en Basys 3

Objetivo y caso de uso

Qué construirás: Generar un patrón de prueba VGA 640×480 en la FPGA Basys 3 utilizando Verilog.

Para qué sirve

• Verificación de la correcta implementación de señales VGA en proyectos de hardware.
• Pruebas de visualización de gráficos en tiempo real en monitores compatibles.
• Desarrollo de habilidades en diseño digital y programación de FPGAs.
• Evaluación de la sincronización de señales hsync y vsync en aplicaciones de video.

Resultado esperado

• Salida de video estable a 640×480 píxeles a 60 Hz.
• Latencia de señal inferior a 10 ms entre la FPGA y el monitor.
• Consumo de recursos de la FPGA por debajo del 30% en el diseño implementado.
• Visualización correcta de patrones de color en todas las áreas visibles de la pantalla.

Público objetivo: Estudiantes y entusiastas de la electrónica; Nivel: Básico

Arquitectura/flujo: Implementación de módulos Verilog en Vivado, síntesis y programación de la FPGA Basys 3.

Nivel: Básico

Prerrequisitos

• Sistema operativo soportado por la toolchain:
• Windows 10/11 64-bit (21H2 o superior recomendado)
• Ubuntu 20.04 LTS o Ubuntu 22.04 LTS 64-bit
• Toolchain exacta:
• Xilinx Vivado Design Suite 2024.2 (edición WebPACK)
  • Vivado (sintetizador, implementador y programador)
  • Cable drivers Digilent/Adept incluidos con Vivado
• Recursos del sistema:
• 8 GB de RAM mínimo (16 GB recomendado)
• 10 GB de espacio libre en disco para instalación + proyecto
• Conocimientos previos:
• Fundamentos de Verilog (módulos, asignaciones, siempre posedge)
• Uso básico de terminal/PowerShell
• Conceptos básicos de sincronismos VGA (hsync/vsync, visible/porches)

Notas sobre versiones:
– Este caso práctico asume Vivado 2024.2 WebPACK (gratuito). Si ya tienes instalado 2024.1, también puedes usarlo; ajusta las rutas y versionado en los comandos en consecuencia. La nomenclatura de parte (xc7a35tcpg236-1) y la placa (Basys 3) no cambian.

Materiales

• 1 x Tarjeta FPGA: Basys 3 (Xilinx Artix-7, Digilent)
• Dispositivo: XC7A35T-1CPG236C
• Reloj de sistema a 100 MHz
• Salida VGA con 12 bits de color (4 bits por canal RGB) + HS/VS
• 1 x Cable micro-USB para alimentación y programación JTAG
• 1 x Cable VGA macho-macho
• 1 x Monitor con entrada VGA (o adaptador VGA->HDMI activo que soporte 640×480@60 Hz; se recomienda monitor VGA nativo para asegurar compatibilidad)
• PC con Vivado 2024.2 (WebPACK) instalado

Opcionales (para validación avanzada):
– Osciloscopio o analizador lógico para medir señales HS/VS
– Multímetro (verificación básica de continuidad del cable)

Preparación y conexión

Descarga del archivo de constraints (XDC) oficial

Para el mapeo de pines, usaremos el archivo oficial de Digilent para Basys 3:

• Archivo: Basys-3-Master.xdc (proporcionado por Digilent en su Resource Center)
• Acción: Descárgalo y colócalo en la carpeta del proyecto, por ejemplo:
• ./constraints/Basys-3-Master.xdc

Importante:
– No edites los números de pin; únicamente “descomenta” las líneas de las señales que vayas a usar, manteniendo los nombres de puertos exactamente como en tu diseño Verilog.
– Este caso práctico usará los nombres de puertos estándar del XDC (CLK100MHZ, VGA_HS, VGA_VS, VGA_R[3:0], VGA_G[3:0], VGA_B[3:0]) para minimizar cambios.

Conexiones físicas

• Conecta el cable micro-USB al puerto PROG (JTAG) de la Basys 3 y al PC.
• Conecta el cable VGA desde el conector VGA de la Basys 3 al monitor.
• Enciende el monitor y selecciona la entrada VGA.
• La Basys 3 se alimenta por el mismo puerto USB. Asegúrate de que el jumper de alimentación esté configurado para USB (normalmente JP2 = USB).

Tabla de puertos (lógica del diseño ↔ interfaz de la placa)

Instrucciones de constraints:
– Abre Basys-3-Master.xdc y descomenta:
– La sección del reloj de 100 MHz (CLK100MHZ) y la línea create_clock correspondiente.
– Las líneas para VGA_HS, VGA_VS.
– Las líneas para VGA_R[3:0], VGA_G[3:0], VGA_B[3:0].
– Mantén los IOSTANDARD LVCMOS33 tal como están en el XDC.

Nota: Al usar los mismos nombres de puertos del XDC, evitas editar los nombres en constraints. Vivado emparejará automáticamente los puertos HDL a esos pines físicos.

Código completo (Verilog) y explicación

El objetivo es generar 640×480@60 Hz y mostrar 8 barras de color verticales. La Basys 3 provee un reloj de 100 MHz; generaremos un reloj de píxel de 25 MHz por división simple entre 4. Aunque el estándar VGA usa 25.175 MHz, el 25.000 MHz suele ser aceptado por la mayoría de monitores. Si tu monitor es estrictamente conforme al estándar, revisa la sección de mejoras para generar 25.175 MHz con el Clocking Wizard.

Puntos clave del diseño

• División de reloj: 100 MHz → 25 MHz mediante un contador de 2 bits.
• Temporización VGA 640×480@60 (aprox):
• Horizontal: 640 visible, 16 front porch, 96 sync, 48 back porch = 800 total
• Vertical: 480 visible, 10 front porch, 2 sync, 33 back porch = 525 total
• HS y VS de polaridad negativa
• Generación de color: 8 barras verticales, 80 píxeles cada una, con colores: blanco, amarillo, cian, verde, magenta, rojo, azul, negro.

Módulo top.v

Guarda este archivo como ./src/top.v (nota: usa los nombres de puertos compatibles con el XDC oficial para Basys 3).

// top.v — VGA 640x480 color bars para Basys 3 (Artix-7)
// Vivado WebPACK 2024.2
// Señales compatibles con Basys-3-Master.xdc (Digilent)

module top (
    input  wire        CLK100MHZ,     // Reloj de 100 MHz de la Basys 3
    output wire        VGA_HS,        // HSync (activo en bajo)
    output wire        VGA_VS,        // VSync (activo en bajo)
    output wire [3:0]  VGA_R,         // Rojo (4 bits)
    output wire [3:0]  VGA_G,         // Verde (4 bits)
    output wire [3:0]  VGA_B          // Azul (4 bits)
);

    //============================================================
    // División de reloj: 100 MHz / 4 = 25 MHz (aprox pixel clock)
    //============================================================
    reg [1:0] div_cnt = 2'd0;
    always @(posedge CLK100MHZ) begin
        div_cnt <= div_cnt + 2'd1;
    end
    wire pix_clk = div_cnt[1]; // 25 MHz aproximado

    //============================================================
    // Parámetros de temporización VGA 640x480@60 (25.175 MHz estándar)
    // Usaremos 25.000 MHz con los mismos contadores:
    // Horizontal (pix): visible=640, fp=16, sync=96, bp=48 => total=800
    // Vertical (line):  visible=480, fp=10, sync=2,  bp=33 => total=525
    //============================================================
    localparam H_VISIBLE = 640;
    localparam H_FP      = 16;
    localparam H_SYNC    = 96;
    localparam H_BP      = 48;
    localparam H_TOTAL   = H_VISIBLE + H_FP + H_SYNC + H_BP; // 800

    localparam V_VISIBLE = 480;
    localparam V_FP      = 10;
    localparam V_SYNC    = 2;
    localparam V_BP      = 33;
    localparam V_TOTAL   = V_VISIBLE + V_FP + V_SYNC + V_BP; // 525

    // Contadores horizontal y vertical
    reg [9:0] h_cnt = 10'd0; // 0..799
    reg [9:0] v_cnt = 10'd0; // 0..524

    always @(posedge pix_clk) begin
        if (h_cnt == H_TOTAL - 1) begin
            h_cnt <= 10'd0;
            if (v_cnt == V_TOTAL - 1) begin
                v_cnt <= 10'd0;
            end else begin
                v_cnt <= v_cnt + 10'd1;
            end
        end else begin
            h_cnt <= h_cnt + 10'd1;
        end
    end

    // Señales de sincronismo (activas en bajo)
    wire hsync = ~((h_cnt >= (H_VISIBLE + H_FP)) && (h_cnt < (H_VISIBLE + H_FP + H_SYNC)));
    wire vsync = ~((v_cnt >= (V_VISIBLE + V_FP)) && (v_cnt < (V_VISIBLE + V_FP + V_SYNC)));

    assign VGA_HS = hsync;
    assign VGA_VS = vsync;

    // Zona visible
    wire visible_area = (h_cnt < H_VISIBLE) && (v_cnt < V_VISIBLE);

    //============================================================
    // Generación de barras de color (8 barras verticales)
    // Cada barra ocupa 640/8 = 80 píxeles de ancho
    // Orden: blanco, amarillo, cian, verde, magenta, rojo, azul, negro
    //============================================================
    wire [2:0] bar = h_cnt[9:7]; // Divide 640 en 8 bloques de 80 (porque 2^7=128; ajustamos poco)
    // Nota: h_cnt[9:7] produce 0..7 sobre 0..1023; en 640 está bien para 0..7
    // Alternativa precisa: integer bar_idx = h_cnt / 80; pero evitamos divisiones en hardware.

    reg [3:0] r, g, b;

    always @* begin
        // Colores por barra
        case (bar)
            3'd0: begin r = 4'hF; g = 4'hF; b = 4'hF; end // blanco
            3'd1: begin r = 4'hF; g = 4'hF; b = 4'h0; end // amarillo
            3'd2: begin r = 4'h0; g = 4'hF; b = 4'hF; end // cian
            3'd3: begin r = 4'h0; g = 4'hF; b = 4'h0; end // verde
            3'd4: begin r = 4'hF; g = 4'h0; b = 4'hF; end // magenta
            3'd5: begin r = 4'hF; g = 4'h0; b = 4'h0; end // rojo
            3'd6: begin r = 4'h0; g = 4'h0; b = 4'hF; end // azul
            default: begin r = 4'h0; g = 4'h0; b = 4'h0; end // negro
        endcase
    end

    // Aplicar color solo en área visible
    assign VGA_R = visible_area ? r : 4'h0;
    assign VGA_G = visible_area ? g : 4'h0;
    assign VGA_B = visible_area ? b : 4'h0;

endmodule

Explicación breve por bloques:
– División de reloj: con un contador de 2 bits se obtiene un bit que conmuta a 25 MHz (aprox), suficiente para la mayoría de monitores con 640×480.
– Contadores h_cnt y v_cnt: recorren los 800 “ticks” horizontales y las 525 líneas verticales. Cuando h_cnt llega a 799, se resetea y v_cnt incrementa; cuando v_cnt llega a 524, se resetea.
– Sincronismos: HS y VS son activos en bajo durante las secciones de pulso (96 píxeles y 2 líneas respectivamente).
– Área visible: solo cuando h < 640 y v < 480 se emiten colores; fuera, se emiten ceros (pantalla negra en porches y sincros).
– Barras de color: dividimos la anchura visible (640) en 8 segmentos. Asignamos valores máximos (0xF) a cada canal RGB según el color deseado.

Sutileza sobre h_cnt[9:7]:
– Como 2^7 = 128, h_cnt[9:7] divide el rango 0..1023 en 8 sectores de 128. En 0..639, abarcará 5 sectores completos y parte del 6º, pero la distribución sigue siendo de 8 grupos sobre 640 con tamaños muy próximos. Para exactitud de 80 píxeles fijos por barra, reemplaza por un comparador con umbrales (0..79, 80..159, etc.). Para un nivel básico, esta versión es suficiente y más ligera.

Si prefieres barras exactamente iguales (80 px cada una), puedes usar:

• bar = (h_cnt < 80) ? 0 :
  (h_cnt < 160) ? 1 :
  … hasta 560 y 640

o implementar un pequeño comparador por tramos.

Compilación, programación y ejecución (CLI Vivado 2024.2)

A continuación se describen los pasos para construir el proyecto, sintetizar, implementar, generar el bitstream y programar la Basys 3 íntegramente desde línea de comandos con Vivado 2024.2 WebPACK.

Estructura sugerida de carpetas

• Proyecto:
• ./src/top.v
• ./constraints/Basys-3-Master.xdc (descargado de Digilent y con las líneas relevantes descomentadas)
• ./scripts/build.tcl

Script TCL de construcción y programación

Guarda como ./scripts/build.tcl:

# build.tcl — Vivado 2024.2 (WebPACK)
# Proyecto: vga_color_bars_basys3
# Dispositivo: xc7a35tcpg236-1 (Basys 3)

set proj_name "vga_color_bars_basys3"
set proj_dir  [file normalize "./vivado_proj"]
set src_file  [file normalize "./src/top.v"]
set xdc_file  [file normalize "./constraints/Basys-3-Master.xdc"]
set part_name "xc7a35tcpg236-1"

# 1) Crear proyecto vacío para el dispositivo correcto
create_project $proj_name $proj_dir -part $part_name -force

# 2) Agregar fuentes HDL
add_files -fileset sources_1 $src_file

# 3) Agregar constraints (XDC) oficial de Digilent con líneas VGA/CLK descomentadas
add_files -fileset constrs_1 $xdc_file

# 4) Establecer top y actualizar
update_compile_order -fileset sources_1
set_property top top [current_fileset]

# 5) Ejecutar síntesis e implementación y generar bitstream
launch_runs synth_1
wait_on_run synth_1

launch_runs impl_1 -to_step write_bitstream
wait_on_run impl_1

# 6) Opcional: escribir una copia del bitstream en una ruta conocida
set bit_file [get_property PROGRESS_WRITES [get_runs impl_1]]
# Alternativa robusta:
write_bitstream -force "$proj_dir/$proj_name.bit"

# 7) Programar la FPGA (con la placa conectada por USB/JTAG)
open_hw
connect_hw_server
open_hw_target

# Seleccionar el primer dispositivo detectado
set hw_device [lindex [get_hw_devices] 0]
current_hw_device $hw_device

# Asignar el bitstream
set_property PROGRAM.FILE "$proj_dir/$proj_name.bit" $hw_device

# Programar
program_hw_devices $hw_device

# Cerrar (opcional)
# close_hw_target
# disconnect_hw_server

Notas:
– Asegúrate de haber descomentado en el XDC las líneas correspondientes a CLK100MHZ y todas las señales VGA antes de ejecutar el script.
– El nombre del módulo top en Verilog es “top”, y se establece como top del proyecto.

Comandos para ejecutar el flujo

• En Linux (Ubuntu 20.04/22.04):
  1) Instala/activa drivers de cable (una sola vez):

  • sudo /opt/Xilinx/Vivado/2024.2/data/xicom/cable_drivers/lin64/install_script/install_drivers
    2) Ejecuta Vivado en modo batch:
  • /opt/Xilinx/Vivado/2024.2/bin/vivado -mode batch -source ./scripts/build.tcl

• En Windows 10/11 (PowerShell):
  1) Drivers (se instalan con Vivado; si fuera necesario, ejecuta el instalador de drivers desde el menú de inicio de Xilinx)
  2) Ejecuta:

  • «C:\Xilinx\Vivado\2024.2\bin\vivado.bat» -mode batch -source .\scripts\build.tcl

Al finalizar, Vivado habrá:
– Sintetizado e implementado el diseño
– Generado el bitstream
– Programado la FPGA con el bitstream

La pantalla debería mostrar las barras de color inmediatamente si todo está correctamente conectado.

Validación paso a paso

1) Verificación visual básica:
– La pantalla debe mostrar 8 barras verticales a pantalla completa, de izquierda a derecha:
1. Blanco
2. Amarillo
3. Cian
4. Verde
5. Magenta
6. Rojo
7. Azul
8. Negro
– No debe haber flicker marcado. El monitor debería indicar resolución 640×480 @ ~60 Hz (a veces 59-60 Hz).
– Si el monitor tiene OSD (menú), revisa la información de señal recibida.

2) Validación de sincronismos con herramientas:
– Con un osciloscopio o analizador lógico y clips adecuados:
– Mide VGA_HS:
– Frecuencia esperada con 25.000 MHz: 25e6 / 800 ≈ 31.25 kHz.
– Pulso activo en bajo de 96 píxeles → 96/25e6 ≈ 3.84 µs de ancho.
– Mide VGA_VS:
– Frecuencia esperada: 31.25e3 / 525 ≈ 59.52 Hz (aprox 60 Hz).
– Pulso activo en bajo de 2 líneas → 2 / 31.25e3 ≈ 64 µs de ancho.
– Si usas 25.175 MHz (ver mejoras), las frecuencias estándar son:
– HS ≈ 31.469 kHz
– VS ≈ 59.94 Hz

3) Validación de área visible:
– La imagen debe ocupar toda el área visible del monitor sin desplazamientos notables.
– Las transiciones entre barras deben ser nítidas. Si ves bandas fuera del área visible, revisa porches en el código.

4) Verificación de color:
– Comprueba que blanco sea realmente blanco (R=G=B al máximo).
– Comprueba que negro sea negro (ausencia de luz).
– Si un color se ve como otro (p.ej. rojo se ve como azul), podría haber mapeo erróneo de pines o mezcla de canales.

5) Mensajes de Vivado:
– Al final de la implementación no deberían aparecer errores (CRITICAL WARNING/ERROR).
– Warnings sobre temporización pueden aparecer por la división simple del reloj; para un proyecto básico y estas frecuencias, suele ser aceptable.

Troubleshooting (5–8 problemas típicos y soluciones)

1) Pantalla en negro sin señal
– Causas:
– El monitor no detecta sincronismos válidos (frecuencia fuera de rango).
– No se programó la FPGA (bitstream no cargado).
– Cable VGA defectuoso o mal conectado.
– Soluciones:
– Verifica programación: vuelve a ejecutar el script y observa que program_hw_devices complete sin errores.
– Prueba con otro cable VGA o monitor.
– Revisa que el XDC correcto esté incluido y las líneas de VGA y CLK estén descomentadas.

2) Imagen “Out of Range” o “Fuera de rango”
– Causa:
– El monitor requiere 25.175 MHz en lugar de 25.000 MHz.
– Solución:
– Usa el Clocking Wizard de Vivado para generar 25.175 MHz desde 100 MHz (ver mejoras/variantes).
– Ajusta los parámetros de porches y sync exactamente a los valores estándar si los cambiaste por error.

3) Colores intercambiados (p.ej., amarillo aparece como magenta)
– Causa:
– Los bits de R/G/B están mapeados incorrectamente (p.ej., R conectado a pines de G).
– Solución:
– Asegúrate de que los nombres de puertos del HDL coincidan con los del XDC oficial (VGA_R, VGA_G, VGA_B).
– Confirma que no renombraste puertos en el HDL. Usa exactamente VGA_R[3:0], VGA_G[3:0], VGA_B[3:0].

4) Imagen desplazada o con bordes visibles incorrectos
– Causas:
– Porches o anchuras de pulso alteradas.
– Un error al usar índices para generar barras (si usas comparaciones con umbrales mal definidas).
– Soluciones:
– Verifica H_VISIBLE/H_FP/H_SYNC/H_BP y V_* según los valores dados.
– Si implementaste barras con divisiones, prueba el enfoque por comparadores de umbrales explícitos.

5) Error de drivers de cable (Vivado no detecta el dispositivo)
– Causas:
– Drivers no instalados, cable inadecuado, conflicto con otra aplicación.
– Soluciones:
– Linux: ejecuta el instalador de drivers (install_drivers) de Vivado con sudo.
– Windows: reinstala drivers desde el menú de Vivado.
– Usa otro puerto USB y cable. Cierra cualquier herramienta que pueda usar JTAG (p.ej. Adept, iMPACT).

6) Warnings de temporización o de reloj derivado
– Causa:
– El reloj de píxel se obtuvo con un simple divisor lógico, lo que puede no generar un “clock” global con BUFG.
– Soluciones:
– Para robustez: usa el Clocking Wizard para generar un clock de píxel (25.000 o 25.175 MHz) y dirigirlo por BUFG automáticamente.
– Alternativamente, usa un “clock enable” en lugar de crear un nuevo clock (más avanzado).

7) Barras con grosor desigual o número incorrecto de barras
– Causa:
– Uso de h_cnt[9:7] produce sectores de 128 cuentas; en 640 puede dar un reparto ligeramente no uniforme visualmente en algunos monitores.
– Solución:
– Implementa barras por umbrales exactos de 80 píxeles: 0..79, 80..159, …, 560..639.

8) Vivado no encuentra el archivo XDC o HDL
– Causa:
– Rutas relativas incorrectas.
– Solución:
– Revisa en build.tcl las rutas a ./src/top.v y ./constraints/Basys-3-Master.xdc. Usa rutas absolutas si es necesario.

Mejoras/variantes

1) Generación de 25.175 MHz exactos con Clocking Wizard
– En Vivado, puedes crear un IP “Clocking Wizard” para generar 25.175 MHz a partir de 100 MHz con un MMCM/PLL.
– Workflow por TCL (resumen):
– create_ip -name clk_wiz -vendor xilinx.com -library ip -version 6.0 -module_name clkgen_25mhz
– Configura el IP para:
– Input: 100 MHz
– Output0: 25.175 MHz (duty cycle 50%, jitter bajo)
– Conecta la salida a pix_clk y usa pix_clk en lugar de la división simple.
– Beneficio:
– Mayor compatibilidad con monitores que exigen precisión de timing estándar (31.469 kHz y 59.94 Hz).

2) Patrón de test SMPTE color bars
– Sustituye la sencilla secuencia RGB por una aproximación del patrón SMPTE (en 8 barras), ajustando niveles intermedios (e.g., 0x8 para semibrillo). Requiere pequeñas tablas de colores.

3) Gradientes horizontales/verticales
– En vez de barras planas, crea gradientes suaves basados en h_cnt y v_cnt, p.ej. VGA_R = h_cnt[9:6]; VGA_G = v_cnt[8:5]; VGA_B = (h_cnt^v_cnt)[9:6].

4) Marco y área de seguridad
– Dibuja un marco blanco alrededor del área visible (píxeles en los bordes) para verificar exactitud de porches y mapeo visible.

5) Detección simple de EDID (avanzado, requeriría I2C)
– En placas con I2C hacia el conector (no es el caso típico del VGA estándar), podrías leer EDID para ajustar timings. Normalmente omitido en VGA simple.

6) Uso de clock enable en vez de reloj derivado
– Mantén todo en CLK100MHZ y usa un “tick” cada 4 ciclos para tu lógica de píxel, reduciendo dominios de reloj y mejorando cierre de temporización (recomendado en diseños más complejos).

7) Añadir multiplexado de patrones
– Usa interruptores (SW) de la Basys 3 para alternar entre barras, gradientes o damero en tiempo real (requiere descomentar SW en el XDC y mapear puertos).

Checklist de verificación

• [ ] He instalado Vivado 2024.2 (WebPACK) en mi sistema (Windows 10/11 o Ubuntu 20.04/22.04).
• [ ] He descargado Basys-3-Master.xdc y lo he colocado en ./constraints/Basys-3-Master.xdc.
• [ ] He descomentado en el XDC las líneas de CLK100MHZ, VGA_HS, VGA_VS y VGA_R/G/B[3:0], sin modificar números de pin ni IOSTANDARD.
• [ ] He creado la carpeta ./src y guardado el archivo ./src/top.v con el código proporcionado (módulo top).
• [ ] He creado la carpeta ./scripts y guardado ./scripts/build.tcl con el contenido proporcionado.
• [ ] He conectado la Basys 3 por micro-USB al PC y el cable VGA al monitor.
• [ ] He ejecutado Vivado en modo batch con el script TCL correspondiente a mi sistema operativo.
• [ ] El proceso de síntesis/implementación/bitstream ha finalizado sin errores.
• [ ] El programador ha detectado la FPGA y ha cargado el bitstream.
• [ ] Veo en el monitor 8 barras de color (blanco, amarillo, cian, verde, magenta, rojo, azul, negro).
• [ ] En caso de problemas, he revisado la sección de Troubleshooting y aplicado las soluciones sugeridas.

---

Apéndice: pasos textuales claros para preparar el XDC

• Abre Basys-3-Master.xdc con un editor de texto.
• Localiza:
• La sección del reloj (CLK100MHZ). Descomenta:
  • set_property PACKAGE_PIN … [get_ports { CLK100MHZ }]
  • set_property IOSTANDARD LVCMOS33 [get_ports { CLK100MHZ }]
  • create_clock -add -name sys_clk_pin -period 10.00 -waveform {0 5} [get_ports { CLK100MHZ }]
• La sección VGA. Descomenta:
  • set_property PACKAGE_PIN … [get_ports { VGA_HS }]
  • set_property PACKAGE_PIN … [get_ports { VGA_VS }]
  • set_property PACKAGE_PIN … [get_ports { VGA_R[0] }]
  • set_property PACKAGE_PIN … [get_ports { VGA_R[1] }]
  • set_property PACKAGE_PIN … [get_ports { VGA_R[2] }]
  • set_property PACKAGE_PIN … [get_ports { VGA_R[3] }]
  • set_property PACKAGE_PIN … [get_ports { VGA_G[0] }]
  • set_property PACKAGE_PIN … [get_ports { VGA_G[1] }]
  • set_property PACKAGE_PIN … [get_ports { VGA_G[2] }]
  • set_property PACKAGE_PIN … [get_ports { VGA_G[3] }]
  • set_property PACKAGE_PIN … [get_ports { VGA_B[0] }]
  • set_property PACKAGE_PIN … [get_ports { VGA_B[1] }]
  • set_property PACKAGE_PIN … [get_ports { VGA_B[2] }]
  • set_property PACKAGE_PIN … [get_ports { VGA_B[3] }]
• Asegúrate de que cada puerto tenga su IOSTANDARD LVCMOS33 y que no existan duplicados.

Nota: Como trabajas sobre el XDC oficial de Digilent, los números de pin ya son correctos para la Basys 3. No los cambies.

---

Apéndice: alternativa de barras con anchos exactos (opcional)

Si prefieres anchos exactos de 80 píxeles, sustituye la lógica de “bar” por:

reg [2:0] bar_exact;
always @* begin
    if      (h_cnt < 80)   bar_exact = 3'd0;
    else if (h_cnt < 160)  bar_exact = 3'd1;
    else if (h_cnt < 240)  bar_exact = 3'd2;
    else if (h_cnt < 320)  bar_exact = 3'd3;
    else if (h_cnt < 400)  bar_exact = 3'd4;
    else if (h_cnt < 480)  bar_exact = 3'd5;
    else if (h_cnt < 560)  bar_exact = 3'd6;
    else                   bar_exact = 3'd7; // 560..639

    case (bar_exact)
        3'd0: begin r = 4'hF; g = 4'hF; b = 4'hF; end // blanco
        3'd1: begin r = 4'hF; g = 4'hF; b = 4'h0; end // amarillo
        3'd2: begin r = 4'h0; g = 4'hF; b = 4'hF; end // cian
        3'd3: begin r = 4'h0; g = 4'hF; b = 4'h0; end // verde
        3'd4: begin r = 4'hF; g = 4'h0; b = 4'hF; end // magenta
        3'd5: begin r = 4'hF; g = 4'h0; b = 4'h0; end // rojo
        3'd6: begin r = 4'h0; g = 4'h0; b = 4'hF; end // azul
        default: begin r = 4'h0; g = 4'h0; b = 4'h0; end // negro
    endcase
end

Esta variante elimina cualquier posible no-uniformidad en el ancho de barras.

---

Con este caso práctico has completado un flujo completo con Vivado 2024.2 WebPACK para la Basys 3 (Artix-7), generando una salida VGA 640×480 con barras de color. El proyecto es una base sólida para añadir patrones, textos, sprites y generadores de reloj más robustos en futuros ejercicios.