Implementación de una interfaz VGA sobre FPGA 
A lo largo de este post se abordará el diseño y la implementación en VHDL de una interfaz de salida VGA para FPGA. La interfaz lee una imagen de 64x48 pixels de una memoria (por ahora una ROM) interna y la renderiza usando el modo VGA estándar de 640x480 a 60Hz.

Señal VGA

Las señales más importantes que viajan por un cable VGA son:

- R (nivel de rojo, mínimo 0 voltios, máximo 0.7 voltios)

- G (nivel de verde, mínimo 0 voltios, máximo 0.7 voltios)

- B (nivel de azul, mínimo 0 voltios, máximo 0.7 voltios)

- Sincronismo horizontal (HSync, señal digital TTL que puede ser de 3.3 voltios)

- Sincronismo vertical (VSync, señal digital TTL que puede ser de 3.3 voltios)

Un flanco de bajada en HSync determina el fin de una línea horizontal de imagen y un flanco de bajada en VSync determina el fin de un fotograma, o de un cuadro). Hay unos "márgenes de seguridad" antes y después (front y back porch) de cada flanco de bajada de HSync de la misma forma que hay unos "márgenes de seguridad" (en forma de líneas en negro) antes y después (front y back porch) de cada flanco de bajada de VSync.

A continuación puede verse un diagrama de tiempos sobre cómo funcionan las señales de color y de sincronismo en un cable VGA:

(imagen copyright © 2017 Scott Larson, extraida de este artículo)


Si asumimos una resolución VGA estándar de 640 x 480 pixels a 60 Hz, tendremos los siguientes valores:
Pixel clockAnchura (pixels)Altura (líneas)
VisiblesNo visiblesVisiblesNo visibles
Front porchHSyncBack porchFront porchHSyncBack porch
25.175 MHz64016964848010233


Con estos valores vemos que, en efecto tenemos una tasa de refresco de:

$${1 \over {{{640+16+96+48} \over {25175000}} \times {\left(480+10+2+33\right)}}}=59.940\ Hz \approx 60\ Hz$$

Como los valores RGB son analógicos (entre 0 y 0.7 voltios), será necesario implementar un DAC (aunque sea de forma rudimentaria) por cada componente de color. Asumiremos una imagen de 8 colores con un bit por cada componente:

000001010011100101110111
negroazulverdecyanrojorosaamarilloblanco


De esta forma tendremos un DAC de 1 bit por cada color. Si la impedancia de entrada de las entradas RGB es de 75 Ohm vemos que con una sencilla resistencia de 270 Ohm en serie construimos un divisor de tensión que genera 0 voltios con un valor lógico 0 (0 voltios de salida digital) y 0.7 voltios con un valor lógico 1 (3.3 voltios de salida digital):

$${0 \times {75 \over {270+75}}}=0\ voltios$$
$${3.3 \times {75 \over {270+75}}}=0.71739\ voltios$$

Por cada píxel hay que almacenar 3 bits pero como las anchuras de bus de 3 bits son raras asumimos que cada pixel ocupa un byte del cual (por ahora) sólo se usan los 3 bits menos significativos.

Como el reloj de nuestra FPGA va a 50 MHz y el pixel clock es de 25.175 MHz se ha optado por asumir una imagen de 64 x 48 pixels. Esto es: cada pixel de la imagen en la memoria se corresponde con un cuadrado de 10 x 10 pixels en la pantalla. Usando esta aproximación, una imagen de 64 x 48 pixels necesita 64 x 48 = 3072 bytes de almacenamiento y el pixel clock se reduce de 25.175 MHz a 2.5175 MHz, que es una frecuencia más fácil de manejar por la FPGA.

Tenemos, por tanto, una memoria de 64 x 48 = 3072 bytes en la que cada byte posee los valores RGB en sus tres bits menos significativos. En cada línea de imagen se deben pintar 64 pixels (con un pixel clock de 2.5175 MHz en lugar de 25.175 MHz para que cada pixel de la memoria ocupe 10 pixels VGA de ancho) y cada línea debe ser pintada 10 veces de idéntica manera.

Ruta de datos y máquina de estados

A continuación puede verse una propuesta de ruta de datos a implementar para la interfaz VGA:


Leyenda:

PW = Pixel width
FP = Front porch (tiempo "en negro" antes del pulso HSync)
BP = Back porch (tiempo "en negro" después del puslto HSync)
LS = Line size, anchura total en pulsos de una línea en blanco de 640 pixels

El registro LineAddr almacena la dirección de comienzo de la línea actual. Es un registro que se incrementa de 64 en 64 y que ayuda a hacer el repetido de líneas (cada una de las 48 líneas de la imagen debe ser repetida 10 veces para renderizar las 480 líneas VGA).

El registro PixelAddr almacena la dirección de memoria del píxel actual que está siendo pintado. Este registro se inicializa siempre con el valor del registro LineAddr y es incrementado de uno en uno, 64 veces por cada línea (64 * 10 pixels = 640 pixels de anchura de la señal VGA).

El registro Pixel almacena el byte de cuyos tres bits más bajos se sacan las señales RGB de forma directa. Está gobernado por un multiplexor que decide si carga datos de la memoria o de la constante 0. Nótese que durante los márgenes de seguridad (front y back porch), durante los intervalos de sincronismo (tanto vertical como horizontal) y durante las lineas de retrazo (las que no se ven, de la 480 a la 524, 45 en total) debe emitirse una señal en negro por los pines RGB.

Se han habilitado además 3 contadores de propósito general que son utilizados por la máquina de estados para controlar los tiempos de cada fase de la señal VGA. La máquina de estados puede verse a continuación:

Los diferentes valores que se aplican a los contadores para controlar los tiempos del protocolo VGA se calculan teniendo en cuenta la frecuencia de reloj usada (50 MHz) y la frecuencia de pixel VGA (25.175 MHz). Por ejemplo el valor de PW (PIXEL_WIDTH) se usa para esperar un tiempo equivalente a 10 pixels:

$$PW={{1 \over 25175000} \times 50000000 \times 10}=20\ pulsos$$

De la misma forma se calcula el resto de valores:

$$FP={{1 \over 25175000} \times 50000000 \times 16}=32\ pulsos$$
$$HSYNC={{1 \over 25175000} \times 50000000 \times 96}=191\ pulsos$$
$$BP={{1 \over 25175000} \times 50000000 \times 48}=95\ pulsos$$
$$LS+BP={{1 \over 25175000} \times 50000000 \times \left(640+16\right)}=1303\ pulsos$$

Estos valores teóricos son luego ajustados ya que en esas ecuaciones sólo se tienen en cuenta los estados de espera y no se contabiliza el resto de estados, que también consumen ciclos de reloj.

Una técnica muy usada para compensar los tiempos de espera en las máquinas de estado es incluir estados que no hacen nada con transiciones vacías (épsilon). Como se puede ver en la imagen anterior, el estado 14 se alcanza siempre al final del renderizado de una línea horizontal VGA. Si Contador3 = 0 entonces se ha terminado una repetición de 10 líneas consecutivas y toca avanzar de línea, pero si Contador3 <> 0 entonces hay que volver a pintar la línea actual (la que está apuntada por el registro LA, LineAddress). En este último caso, la máquina de estados pasa por tres estados que no hacen nada (26, 27 y 28) pero que se han colocado ahí para que no haya diferencia entre la cantidad de ciclos que tarda una línea repetida y la cantidad de ciclos que tarda una línea nueva.

Buffers de salida para los sincronismos

Aunque la máquina de estados ya genera directamente las señales HSync y VSync, es necesario hacerlas pasar por un latch (biestable D) para garantizar que quedan libres de gitches.

    -- acondicionador de señales HSync y VSync
    process (Clk)
    begin
        if (Clk'event and (Clk = '1')) then
            HSyncQBus <= HSyncDBus;
        end if;
    end process;

    HSyncDBus <= HSyncIn;
    HSyncOut <= HSyncQBus;

    process (Clk)
    begin
        if (Clk'event and (Clk = '1')) then
            VSyncQBus <= VSyncDBus;
        end if;
    end process;

    VSyncDBus <= VSyncIn;
    VSyncOut <= VSyncQBus;


Si no se colocasen estos latches y se cableasen directamente las salidas HSync y VSync a los pines de la PFGA podría ocurrir que transiciones intermedias espúreas entre estados generasen pulsos "fantasma" en dichas salidas. Haciendo pasar a estas señales por un latch se garantiza una carga atrasada y limpia que disminuye la probabilidad de que se produzcan estos glitches.

Por claridad, estos latches no se muestran en el diagrama con la ruta de datos mostrado anteriormente.

Código fuente e implementación

La máquina de estados se ha implementado, como otras veces, siguiendo el modelo estándar de máquina de Moore:

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity FSM is
    port (
        Clk               : in std_logic;
        Reset             : in std_logic;
        Counter1IsZero    : in std_logic;
        Counter2IsZero    : in std_logic;
        Counter3IsZero    : in std_logic;
        LineAddrIsVisible : in std_logic;
        Counter2IsVSync   : in std_logic;
        Counter1Mux       : out std_logic_vector(2 downto 0);
        Counter2Mux       : out std_logic_vector(1 downto 0);
        Counter3Mux       : out std_logic_vector(1 downto 0);
        LineAddrMux       : out std_logic_vector(1 downto 0);
        PixelAddrMux      : out std_logic_vector(1 downto 0);
        PixelMux          : out std_logic_vector(1 downto 0);
        HSync             : out std_logic;
        VSync             : out std_logic
    );
end entity;

architecture A of FSM is
    signal DBus : std_logic_vector(4 downto 0);
    signal QBus : std_logic_vector(4 downto 0);
begin
    -- lógica de estado siguiente
    DBus <= "00000" when (Reset = '1') else
            "00001" when ((QBus = "00000") or ((QBus = "11101") and (Counter2IsZero = '1'))) else
            "00010" when ((QBus = "00001") or (QBus = "11100") or (QBus = "11001")) else
            "00011" when ((QBus = "00010") or ((QBus = "00110") and (Counter2IsZero = '0'))) else
            "00100" when ((QBus = "00011") or ((QBus = "00100") and (Counter1IsZero = '0'))) else
            "00101" when ((QBus = "00100") and (Counter1IsZero = '1')) else
            "00110" when (QBus = "00101") else
            "00111" when ((QBus = "00110") and (Counter2IsZero = '1')) else
            "01000" when ((QBus = "00111") or ((QBus = "01000") and (Counter1IsZero = '0'))) else
            "01001" when ((QBus = "01000") and (Counter1IsZero = '1')) else
            "01010" when ((QBus = "01001") or ((QBus = "01010") and (Counter1IsZero = '0'))) else
            "01011" when ((QBus = "01010") and (Counter1IsZero = '1')) else
            "01100" when ((QBus = "01011") or ((QBus = "01100") and (Counter1IsZero = '0'))) else
            "01101" when ((QBus = "01100") and (Counter1IsZero = '1')) else
            "01110" when (QBus = "01101") else
            "01111" when ((QBus = "01110") and (Counter3IsZero = '1')) else
            "10000" when (QBus = "01111") else
            "10001" when ((QBus = "10000") and (LineAddrIsVisible = '0')) else
            "10010" when ((QBus = "10001") or ((QBus = "11101") and (Counter2IsZero = '0'))) else
            "10011" when ((QBus = "10010") or ((QBus = "10011") and (Counter1IsZero = '0'))) else
            "10100" when ((QBus = "10011") and (Counter1IsZero = '1')) else
            "10101" when ((QBus = "10100") or ((QBus = "10101") and (Counter1IsZero = '0'))) else
            "10110" when ((QBus = "10101") and (Counter1IsZero = '1')) else
            "10111" when ((QBus = "10110") or ((QBus = "10111") and (Counter1IsZero = '0'))) else
            "11000" when ((QBus = "10111") and (Counter1IsZero = '1')) else
            "11001" when ((QBus = "10000") and (LineAddrIsVisible = '1')) else
            "11010" when ((QBus = "01110") and (Counter3IsZero = '0')) else
            "11011" when (QBus = "11010") else
            "11100" when (QBus = "11011") else
            "11101" when (QBus = "11000") else
            "00000";

    -- lógica de salida
    Counter1Mux <= "001" when (QBus = "00011") else   -- cargar anchura de pixel
                   "010" when (QBus = "00111") else   -- cargar front porch
                   "011" when ((QBus = "01001") or (QBus = "10100")) else   -- cargar HSYNC
                   "100" when ((QBus = "01011") or (QBus = "10110")) else   -- cargar back porch
                   "101" when (QBus = "10010") else   -- cargar anchura línea + front porch
                   "110" when ((QBus = "00100") or (QBus = "01000") or (QBus = "01010") or (QBus = "01100") or (QBus = "10011") or (QBus = "10101") or (QBus = "10111")) else   -- decrementar
                   "000";
    Counter2Mux <= "01" when (QBus = "00010") else   -- cargar 64 (la anchura de línea)
                   "10" when ((QBus = "00101") or (QBus = "11000")) else   -- decrementar
                   "11" when (QBus = "10001") else   -- cargar 45 (cantidad de líneas de blanqueo)
                   "00";
    Counter3Mux <= "01" when ((QBus = "00001") or (QBus = "11001")) else   -- cargar 10 (líneas a repetir)
                   "10" when (QBus = "01101") else   -- decrementar
                   "00";
    LineAddrMux <= "01" when (QBus = "00001") else   -- cargar 0
                   "10" when (QBus = "01111") else   -- incrementar en 64
                   "00";
    PixelAddrMux <= "01" when (QBus = "00010") else
                    "10" when (QBus = "00101") else
                    "00";
    PixelMux <= "01" when ((QBus = "00001") or (QBus = "00111")) else  -- cargar 0
                "10" when (QBus = "00011") else                        -- cargar dato de la ROM
                "00";
    HSync <= '0' when ((QBus = "01001") or (QBus = "01010") or (QBus = "10100") or (QBus = "10101")) else
             '1';
    VSync <= '0' when (((QBus = "10010") or (QBus = "10011") or (QBus = "10100") or (QBus = "10101") or (QBus = "10110") or (QBus = "10111") or (QBus = "11000") or (QBus = "11101")) and (Counter2IsVSync = '1')) else
             '1';

    -- biestables
    process (Clk)
    begin
        if (Clk'event and (Clk = '1')) then
            QBus <= DBus;
        end if;
    end process;
end architecture;


El resto de la implementación consiste en codificar lo registros y los multiplexores:

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity AllButFSM is
    port (
        Clk               : in std_logic;
        LineAddrMux       : in std_logic_vector(1 downto 0);
        PixelAddrMux      : in std_logic_vector(1 downto 0);
        PixelMux          : in std_logic_vector(1 downto 0);
        PixelValue        : out std_logic_vector(7 downto 0);
        HSyncIn           : in std_logic;
        HSyncOut          : out std_logic;
        VSyncIn           : in std_logic;
        VSyncOut          : out std_logic;
        Counter1Mux       : in std_logic_vector(2 downto 0);
        Counter1IsZero    : out std_logic;
        Counter2Mux       : in std_logic_vector(1 downto 0);
        Counter2IsZero    : out std_logic;
        Counter2IsVSync   : out std_logic;
        Counter3Mux       : in std_logic_vector(1 downto 0);
        Counter3IsZero    : out std_logic;
        LineAddrIsVisible : out std_logic
    );
end entity;

architecture A of AllButFSM is
    component Rom is
        generic (
            Log2NumRows : integer := 12   -- 4096 bytes
        );
        port (
            AddressIn : in std_logic_vector((Log2NumRows - 1) downto 0);
            DataOut   : out std_logic_vector(7 downto 0)
        );
    end component;
    component Counter1 is
        port (
            Clk    : in std_logic;
            Mux    : in std_logic_vector(2 downto 0);
            IsZero : out std_logic
        );
    end component;
    component Counter2 is
        port (
            Clk     : in std_logic;
            Mux     : in std_logic_vector(1 downto 0);
            IsZero  : out std_logic;
            IsVSync : out std_logic
        );
    end component;
    component Counter3 is
        port (
            Clk     : in std_logic;
            Mux     : in std_logic_vector(1 downto 0);
            IsZero  : out std_logic
        );
    end component;
    signal LineAddrDBus : std_logic_vector(11 downto 0);   -- 12 bits = 4096 bytes (sólo se usan los 64 * 48 = 3072 primeros bytes)
    signal LineAddrQBus : std_logic_vector(11 downto 0);
    signal PixelAddrDBus : std_logic_vector(11 downto 0);
    signal PixelAddrQBus : std_logic_vector(11 downto 0);
    signal RomOut : std_logic_vector(7 downto 0);
    signal PixelDBus : std_logic_vector(7 downto 0);
    signal PixelQBus : std_logic_vector(7 downto 0);
    signal HSyncDBus : std_logic;
    signal HSyncQBus : std_logic;
    signal VSyncDBus : std_logic;
    signal VSyncQBus : std_logic;
    constant FIRST_NO_VISIBLE_LINE_ADDRESS : integer := 3072;     -- Dirección de memoria de la primera línea no visible
begin
    -- dirección de inicio de la línea actual de pantalla
    process (Clk)
    begin
        if (Clk'event and (Clk = '1')) then
            LineAddrQBus <= LineAddrDBus;
        end if;
    end process;

    LineAddrDBus <= std_logic_vector(to_signed(0, 12)) when (LineAddrMux = "01") else
                    std_logic_vector(to_signed(to_integer(signed(LineAddrQBus)) + 64, 12)) when (LineAddrMux = "10") else    -- 64 bytes (pixels) por línea
                    LineAddrQBus;
    LineAddrIsVisible <= '0' when (to_integer(unsigned(LineAddrQBus)) = FIRST_NO_VISIBLE_LINE_ADDRESS) else
                         '1';

    -- dirección del actual pixel
    process (Clk)
    begin
        if (Clk'event and (Clk = '1')) then
            PixelAddrQBus <= PixelAddrDBus;
        end if;
    end process;

    PixelAddrDBus <= LineAddrQBus when (PixelAddrMux = "01") else
                     std_logic_vector(to_signed(to_integer(signed(PixelAddrQBus)) + 1, 12)) when (PixelAddrMux = "10") else    -- 1 byte = 1 pixel
                     PixelAddrQBus;

    -- ROM con la imagen de 64 x 48 pixels (1 byte por pixel, 64 * 48 = 3072 bytes)
    R : Rom generic map (
        Log2NumRows => 12
    )
    port map (
        AddressIn => PixelAddrQBus,
        DataOut => RomOut
    );

    -- buffer de salida de la ROM (pixel actual)
    process (Clk)
    begin
        if (Clk'event and (Clk = '1')) then
            PixelQBus <= PixelDBus;
        end if;
    end process;

    PixelDBus <= RomOut when (PixelMux = "10") else
                 std_logic_vector(to_signed(0, 8)) when (PixelMux = "01") else
                 PixelQBus;
    PixelValue <= PixelQBus;

    -- contadores
    C1 : Counter1 port map (
        Clk => Clk,
        Mux => Counter1Mux,
        IsZero => Counter1IsZero
    );

    C2 : Counter2 port map (
        Clk => Clk,
        Mux => Counter2Mux,
        IsZero => Counter2IsZero,
        IsVSync => Counter2IsVSync
    );

    C3 : Counter3 port map (
        Clk => Clk,
        Mux => Counter3Mux,
        IsZero => Counter3IsZero
    );

    -- acondicionador de señales HSync y VSync
    process (Clk)
    begin
        if (Clk'event and (Clk = '1')) then
            HSyncQBus <= HSyncDBus;
        end if;
    end process;

    HSyncDBus <= HSyncIn;
    HSyncOut <= HSyncQBus;

    process (Clk)
    begin
        if (Clk'event and (Clk = '1')) then
            VSyncQBus <= VSyncDBus;
        end if;
    end process;

    VSyncDBus <= VSyncIn;
    VSyncOut <= VSyncQBus;
end architecture;


La imagen se aloja en una ROM cuyos datos se especifican directamente en el código fuente de Rom.vhd. Para generar la imagen en formato VHDL usando el GIMP se hicieron los siguientes pasos:

- Se creó una nueva imagen de 64 x 48 pixels.

- Menú Ventanas -- Diálogos empotrables -- Paletas -- Botón derecho dentro del listado de paletas -- Importar paleta -- En "Seleccionar origen" se marcó "Archivo de la paleta" y se seleccionó el fichero "vga_fpga.gpl" que se ha incluido dentro del proyecto. Esto creó dentro del GIMP una nueva paleta de 8 colores que se correspondía con los 8 colores que genera nuestra FPGA.

- Se trabajó la imagen de 64x48 con esa paleta.

- Cuando se terminó de trabajar con la imagen, menú Imagen -- Modo -- Indexado -- En "Mapa de colores" se marcó la opción "Usar paleta personal", se seleccionó la paleta acabante de crear a partir del fichero "vga_fpga.gpl", se desmarcó la opción "Eliminar los colores sin usar de la paleta final" y "Aceptar".

- Menú Archivo -- Exportar como -- Se seleccionó como tipo de archivo "Cabecera de código fuente en C (.h)" -- Exportar

Esto creó un fichero .h con un array con el mapa de color (la paleta) y otro array de 3072 bytes con la imagen completa. Afortunadamente el formato de datos de array de C y VHDL es relativamente similar por lo que simplemente hubo que trabajar un poco con el comando "sed" para adaptar los datos. Por ejemplo, un bloque de texto de esta forma:

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,
7,0,0,0,0,0,0,0,0,0,0,0,0,0,3,3,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,
7,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,3,3,3,
3,0,0,3,3,3,0,0,0,0,3,3,3,0,0,0,


Puede convertirse a formato de datos VHDL de esta forma:

$ cat datos.txt | sed -e 's/0/x"00"/g' | sed -e 's/1/x"01"/g' | sed -e 's/2/x"02"/g' | sed -e 's/3/x"03"/g' | sed -e 's/4/x"04"/g' | sed -e 's/5/x"05"/g' | sed -e 's/6/x"06"/g' | sed -e 's/7/x"07"/g'


Generando la salida:
x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",
x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"07",
x"07",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"03",x"03",
x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",
x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",
x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"07",
x"07",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"03",x"00",x"00",
x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"00",x"03",x"03",x"03",
x"03",x"00",x"00",x"03",x"03",x"03",x"00",x"00",x"00",x"00",x"03",x"03",x"03",x"00",x"00",x"00",


Que es fácilmente incluible en un fichero VHDL como un array (ver Rom.vhd).

Circuito

El circuito externo a la FPGA sólo requiere las líneas de reset, de reloj y de sincronismo conectadas directamente y cada una de las tres líneas de componentes de color (RGB) conectada con una resistencia en serie de 270 Ohm.



El resultado:





Como siempre, todo el código fuente está disponible en la sección soft.

Comentarios 

Agregar comentario

Rellene los campos de abajo para dejar su comentario.









Extras (Negrita / Cursiva / URL / Imagen):