Dominando el diseño embebido con FPGA: Guía práctica de implementación

La disponibilidad de FPGAs más potentes y entornos de programación más efectivos ha hecho que la implementación con FPGA sea ampliamente accesible, pero usar FPGAs puede parecer desalentador.

Nota del editor: A medida que algoritmos avanzados continúan surgiendo para diseños de productos inteligentes, los desarrolladores a menudo se encuentran luchando para implementar sistemas embebidos capaces de satisfacer las demandas de procesamiento asociadas. Las FPGAs pueden ofrecer el rendimiento requerido, pero diseñar con FPGAs ha sido considerado durante mucho tiempo limitado al ámbito de expertos en programación de FPGA. Hoy, sin embargo, la disponibilidad de FPGAs más potentes y entornos de desarrollo más efectivos ha hecho que el desarrollo con FPGA sea ampliamente accesible. En este extracto, el Capítulo 4 del libro Architecting High-Performance Embedded Systems, el autor ofrece una revisión exhaustiva de dispositivos FPGA, lenguajes de implementación y el proceso de desarrollo FPGA, así como un recorrido detallado de cómo comenzar a implementar FPGAs en su propio diseño. El extracto completo se presenta en la siguiente serie de entregas:
1: Recursos de hardware 
2: Lenguajes de implementación 
3: Proceso de desarrollo
4: Construcción de un proyecto
5: Implementación (este artículo)

Adaptado de Architecting High-Performance Embedded Systems, por Jim Ledin.

---

Prueba del comportamiento lógico

Es importante probar el comportamiento de la lógica mediante simulación antes de intentar ejecutarla en la FPGA. Esto es porque es mucho más fácil detectar y corregir problemas en el entorno de simulación que con la lógica ejecutándose dentro de la FPGA. Las herramientas de simulación de Vivado hacen un muy buen trabajo representando el comportamiento del circuito:

1. En la sub-ventana Sources, haga clic derecho en Simulation Sources y seleccione Add Sources…:

Figura 4.18 – Selección de menú Add Sources… para Simulation Sources

2. En el diálogo Add Sources, asegúrese de que Add or create simulation sources esté seleccionado, luego haga clic en Next.
3. En el diálogo Add or Create Simulation Sources, haga clic en Create File.
4. Ingrese el nombre de archivo vhdl y haga clic en OK.
5. Haga clic en Finish para cerrar el diálogo Add or Create Simulation Sources, luego haga clic en OK en el diálogo Define Module y haga clic en Yes cuando se le pregunte si está seguro de querer usar estos.
6. Haga doble clic en Adder4 TestBench (Behavioral) (Adder4TestBench.vhdl) bajo Simulation Sources. Elimine el contenido autogenerado del editor vhdl e ingrese el siguiente código en el editor Adder4TestBench.vhdl:

library IEEE;   use IEEE.STD_LOGIC_1164.ALL;   use IEEE.NUMERIC_STD.ALL; entity ADDER4_TESTBENCH is end entity ADDER4_TESTBENCH; architecture BEHAVIORAL of ADDER4_TESTBENCH is   component ADDER4 is     port (       A4       : in    std_logic_vector(3 downto 0);       B4       : in    std_logic_vector(3 downto 0);       SUM4     : out   std_logic_vector(3 downto 0);       C_OUT4   : out   std_logic     );   end component;   signal a            : std_logic_vector(3 downto 0);   signal b            : std_logic_vector(3 downto 0);   signal s            : std_logic_vector(3 downto 0);   signal c_out        : std_logic;   signal expected_sum5: unsigned(4 downto 0);   signal expected_sum4: unsigned(3 downto 0);   signal expected_c   : std_logic;   signal error        : std_logic; begin   TESTED_DEVICE: ADDER4     port map (       A4     => a,       B4     => b,       SUM4   => s,       C_OUT4 => c_out     );   TEST: process   begin     -- Test all combinations of two 4-bit addends (256 total tests)     for a_val in 0 to 15 loop       for b_val in 0 to 15 loop         -- Set the inputs to the ADDER4 component         a <= std_logic_vector(to_unsigned(a_val, a'length));         b <= std_logic_vector(to_unsigned(b_val, b'length));         wait for 1 ns;         -- Compute the 5-bit sum of the two 4-bit values         expected_sum5 <= unsigned('0' & a) + unsigned('0' & b);         wait for 1 ns;         -- Break the sum into a 4-bit output and a carry bit         expected_sum4 <= expected_sum5(3 downto 0);         expected_c    <= expected_sum5(4);         wait for 1 ns;         -- The 'error' signal will only go to 1 if an error occurs         if ((unsigned(s) = unsigned(expected_sum4)) and             (c_out = expected_c)) then           error <= '0';         else           error <= '1';         end if;         -- Each pass through the inner loop takes 10 ns         wait for 7 ns;       end loop;     end loop;     wait;   end process TEST; end architecture BEHAVIORAL;

Este código ejercita la funcionalidad del sumador de 4 bits presentando todas las combinaciones de números de 4 bits a cada una de las entradas A4 y B4 del componente Adder4. Compara las salidas SUM4 y C_OUT4 del componente Adder4 con valores calculados independientemente para las mismas entradas. Tras cada operación de suma, la señal error se establece en 0 si las salidas de Adder4 coincidieron con los valores esperados, o en 1 si hay discrepancia.

El código en Adder4TestBench.vhdl se asemeja al código de software tradicional en su uso de bucles for anidados para aplicar todas las combinaciones de entrada de prueba al componente Adder4 bajo prueba. El código que ejecuta pruebas en modo simulación no es sintetizable, lo que significa que no representa puramente un circuito lógico de hardware y es capaz de operaciones similares a software tradicionales, como la ejecución iterativa de bucles for.

Sin embargo, al igual que en circuitos físicos, las señales a las que se asignan valores en el código del test bench usando el operador <= no pueden usarse en el mismo instante en expresiones subsiguientes. Esto es porque el entorno de simulación representa los efectos reales del retardo de propagación, que es significativo incluso dentro de diminutos dispositivos FPGA. Las tres sentencias wait for 1 ns; en el código del test bench pausan las operaciones del circuito para permitir el retardo de propagación. Estos retrasos de 1 ns dan tiempo para que los valores de señal calculados justo antes de la sentencia wait se propaguen para poder usarse en la siguiente sentencia. La última sentencia wait for 7 ns; en el bucle interno es una pausa que nos permite ver claramente los resultados de cada iteración de los bucles de simulación en la visualización de trazas de señal.

7. Haga clic derecho en Adder4 TestBench (Behavioral) (Adder4TestBench.vhdl) bajo Simulation Sources y seleccione Automatic Update and Compile Order. Esto establece ADDER4_TESTBENCH como objeto de nivel superior para la ejecución de simulación:

Figura 4.19 – Selección de menú para establecer Automatic Update and Compile Order

8. Haga clic en Run Simulation, luego Run Behavioral Simulation en la ventana Flow Navigator para entrar en modo simulación. Si aún no ha guardado los archivos del editor, se le pedirá que lo haga. Haga clic en Save. La simulación se ejecutará entonces:

Figura 4.20 – Selección de menú Run Behavioral Simulation

9. Cuando se abra la ventana SIMULATION, haga clic en el botón maximizar en la ventana de salida de simulación con el título Untitled 1:

Figura 4.21 – Ventana de resultados de simulación

El tiempo simulado total de cada pasada por el bucle interno es 10 ns. Como hay 256 pasadas por el bucle en Adder4TestBench.vhdl, el tiempo para ejecutar la simulación es 2560 ns.

10. Establezca el tiempo de ejecución de simulación a 2560 ns en la barra de herramientas superior (paso 1 en la siguiente figura), presione el botón de reinicio hacia la izquierda (paso 2), luego presione el botón hacia la derecha para ejecutar la simulación por 2560 ns (paso 3), y finalmente presione el botón Zoom Fit (paso 4) para escalar el rango de datos de salida de simulación a la ventana:

Figura 4.22 – Resultados de simulación desde el inicio hasta el final de la ejecución

Puede usar los iconos de lupa para hacer zoom en cualquier punto de la traza y observar los resultados de cada operación de suma realizada durante la prueba. Por ejemplo, la siguiente figura muestra que los valores decimales 6 y 2 se sumaron para producir el resultado 8 con acarreo 0. Estos valores coinciden con los esperados, lo que hizo que error se estableciera en 0. La señal error es 0 para todos los 256 casos de prueba, indicando que nuestro circuito lógico pasó todas las pruebas:

Figura 4.23 – Vista ampliada de los resultados de simulación

11. Cierre el modo simulación haciendo clic en la X en la barra azul SIMULATION encima de la traza de datos. Haga clic en OK cuando se le pregunte si desea cerrar la simulación.

Habiendo superado la prueba conductual, definiremos las señales de E/S usadas en el diseño.

Definición de señales de E/S

Nuestro siguiente paso es conectar las entradas y salidas de nuestro circuito a dispositivos de hardware en la placa Arty. Las entradas serán los interruptores y pulsadores de la placa, y las salidas serán los LEDs.

Los siguientes pasos crearán un archivo de restricciones que describe los pines de E/S que usaremos en el dispositivo FPGA y las funciones conectadas a esos pines en la placa Arty. Los archivos de restricciones tienen extensión xdc:

1. En la sub-ventana Sources, haga clic derecho en Constraints y seleccione Add Sources….
2. En el diálogo Add Sources, asegúrese de que Add or create constraints esté seleccionado, luego haga clic en Next.
3. En el diálogo Add or Create Constraints, haga clic en Create File.
4. Ingrese el nombre de archivo Arty-A7-100.xdc (o Arty-A7-35.xdc si es apropiado para su dispositivo) y haga clic en OK.
5. Haga clic en Finish para cerrar el diálogo Add or Create Constraints.
6. Expanda el árbol de fuentes Constraints y haga doble clic en Arty-A7-35.xdc.
7. Digilent proporciona archivos de restricciones pre-poblados para las placas Arty A7. Visite https://raw.githubusercontent.com/Digilent/digilent-xdc/master/Arty-A7-35-Master.xdc y copie todo el contenido de la ventana del navegador en la ventana del editor Arty-A7-35.xdc en Vivado. Si es apropiado para su dispositivo, use el archivo en https://raw.githubusercontent.com/Digilent/digilent-xdc/master/Arty-A7-100-Master.xdc en su lugar.
8. Todos los pines de E/S están comentados en el archivo de restricciones por el carácter #. Descomente las líneas apropiadas eliminando el # al inicio de cada línea. Usaremos los pines listados en las siguientes secciones en el archivo Arty-A7-100.xdc: Switches, RGB LEDs (solo led0_g, el primer LED verde), LEDs, y Buttons. La siguiente figura muestra estas líneas después de haber sido descomentadas:

Figura 4.24 – Ventana editor de restricciones

En la siguiente sección, crearemos un archivo VHDL de nivel superior que interconecte el código del sumador con los dispositivos de E/S.

Creación de un archivo VHDL de nivel superior

A continuación, crearemos un archivo VHDL de nivel superior que conecte nuestro sumador de 4 bits a las señales de E/S correspondientes de la placa:

1. En la sub-ventana Sources, haga clic derecho en Design Sources y seleccione Add Sources….
2. En el diálogo Add Sources, asegúrese de que Add or create design sources esté seleccionado, luego haga clic en Next.
3. En el diálogo Add or Create Design Sources, haga clic en Create File.
4. Ingrese el nombre de archivo vhdl y haga clic en OK.
5. Haga clic en Finish para cerrar el diálogo Add or Create Design Sources, luego haga clic en OK en el diálogo Define Module y haga clic en Yes cuando se le pregunte si está seguro de querer usar estos.
6. Haga doble clic en vhdl bajo Design Sources. Elimine el contenido autogenerado de la ventana del editor ArtyAdder.vhdl e ingrese el siguiente código en el editor ArtyAdder.vhdl:

-- Load the standard libraries library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity ARTY_ADDER is    port (        sw         : in STD_LOGIC_VECTOR (3 downto 0);        btn        : in STD_LOGIC_VECTOR (3 downto 0);        led        : out STD_LOGIC_VECTOR (3 downto 0);        led0_g     : out STD_LOGIC    ); end entity ARTY_ADDER; architecture BEHAVIORAL of ARTY_ADDER is -- Reference the previous definition of the 4-bit adder component ADDER4 is port (    A4       : in   std_logic_vector(3 downto 0);    B4       : in   std_logic_vector(3 downto 0);    SUM4     : out  std_logic_vector(3 downto 0);    C_OUT4   : out  std_logic ); end component; begin ADDER : ADDER4    port map (      A4        => sw,      B4        => btn,      SUM4      => led,      C_OUT4    => led0_g    ); end architecture BEHAVIORAL;

Este código mapea los nombres de señales para los dispositivos de E/S nombrados en Arty-A7-100.xdc como sw (4 interruptores), btn (4 pulsadores), led (4 LEDs de un solo color), y led0_g (el canal verde del primer LED multicolor) a las entradas y salidas del ADDER4.

Aunque VHDL no distingue mayúsculas/minúsculas, el procesamiento de archivos de restricciones xdc en Vivado sí lo hace. El caso usado en nombres de dispositivos de E/S definidos en el archivo xdc debe ser idéntico cuando se referencian en un archivo VHDL. Específicamente, los nombres de señales de E/S en VHDL deben ser minúsculas en este archivo porque lo son en el archivo de restricciones.

Ahora estamos listos para sintetizar, implementar y programar nuestro diseño para la placa Arty.

Síntesis e implementación del bitstream FPGA

Alternativamente, puede seleccionar Generate Bitstream y Vivado realizará todos los pasos requeridos, incluyendo síntesis, implementación y generación de bitstream sin más intervención del usuario. Si ocurre un error fatal, el proceso se detendrá y se mostrarán mensajes de error. Realice los siguientes pasos para generar el bitstream:

1. Haga clic en Generate Bitstream para iniciar la compilación. Puede que se le pregunte si desea guardar editores de texto. Haga clic en Save. Puede que se le informe que no hay resultados de implementación disponibles y se le pregunte si está bien lanzar síntesis e implementación. Haga clic en Yes:

Figura 4.25 – Selección de menú Generate Bitstream

2. El diálogo Launch Runs aparecerá. Puede seleccionar un valor para Number of jobs hasta el número de núcleos de procesador en su computadora. Usar más núcleos acelera el proceso, pero puede ralentizar su máquina si desea seguir usándola durante una compilación prolongada. Haga clic en OK para iniciar la compilación:

Figura 4.26 – Diálogo Launch Runs

3. Durante el proceso de compilación, Vivado mostrará el estado en la esquina superior derecha de la ventana principal. Si es necesario, puede cancelar el proceso haciendo clic en Cancel junto a la visualización de estado:

Figura 4.27 – Visualización de estado de compilación

4. Cuando el proceso de compilación finalice, asumiendo que no hubo errores fatales, aparecerá un diálogo Bitstream Generation Completed. Aunque se ofrecen otras opciones, procederemos directamente a descargar el bitstream a la placa Arty. Seleccione Open Hardware Manager y haga clic en OK:

Figura 4.28 – Diálogo Bitstream Generation Completed

A continuación, descargaremos el bitstream al FPGA.

Descarga del bitstream a la placa

Realice los siguientes pasos para descargar el bitstream a una placa Arty A7:

1. El diálogo HARDWARE MANAGER aparecerá e indicará No hardware target is open.
2. Conecte su placa Arty A7-35 o A7-100 a la computadora con un cable USB. Espere unos segundos a que la placa sea reconocida, luego haga clic en Open target, luego Auto Connect:

Figura 4.29 – Selecciones Open target y Auto Connect

3. Tras unos segundos, Vivado debería indicar que la placa está conectada. Haga clic en Program device para descargar el bitstream FPGA a la Arty. Se le pedirá que seleccione un archivo de bitstream. Si ha usado la misma estructura de directorios que este ejemplo, el archivo estará en C:/Projects/ArtyAdder/ArtyAdder.runs/impl_1/ARTY_ADDER.bit:

Figura 4.30 – Diálogo Program Device

4. Haga clic en Program para descargar el programa al dispositivo FPGA e iniciarlo.
5. Ahora puede probar el funcionamiento del programa con la E/S de Arty. Coloque los cuatro interruptores en posición off (mueva los interruptores hacia el borde adyacente de la placa) y no presione ninguno de los cuatro pulsadores. Los cuatro LEDs verdes deberían estar apagados.
6. Si enciende cualquier interruptor individual o presiona cualquier pulsador, el LED verde correspondiente debería encenderse. Encender cualquier combinación de interruptores mientras presiona cualquier número de pulsadores sumará los correspondientes números de 4 bits y encenderá los LEDs con el resultado. Si hay acarreo (por ejemplo, encienda SW3 y presione BTN3 simultáneamente), el LED verde de acarreo se iluminará.

El proceso de programación realizado aquí almacenó el programa en RAM de la FPGA. Si cicla la alimentación de la placa FPGA, necesitará repetir el proceso de programación para recargar el programa. Alternativamente, puede almacenar el archivo de configuración FPGA en memoria flash a bordo como se describe en la siguiente sección.

Programación del bitstream en memoria flash a bordo

Para configurar la FPGA cada vez que se aplique energía a la placa Arty, el archivo de configuración FPGA debe almacenarse en la memoria flash de la placa. Si el jumper MODE está instalado, la FPGA intentará descargar un archivo de configuración desde la flash a bordo al encender. Esta memoria se encuentra en un chip separado adyacente al FPGA Artix-7. Siga estos pasos para programar el archivo de configuración en la memoria flash:

1. Instale el jumper MODE en la placa Arty si no está ya puesto.
2. Haga clic derecho en Generate Bitstream y seleccione Bitstream Settings….
3. En el diálogo Settings, marque la casilla junto a -bin_file y haga clic en OK:

Figura 4.31 – Diálogo Bitstream settings

4. En el diálogo principal de Vivado, haga clic en Generate Bitstream y repita el proceso de generación de bitstream. Haga clic en Cancel cuando aparezca el diálogo Bitstream Generation Completed.

5. En el diálogo Hardware, haga clic derecho en el número de parte FPGA (xc7a100t_0) y seleccione Add Configuration Memory Device…:

Figura 4.32 – Selección de menú Add Configuration Memory Device…

6. Escriba s25fl127 en el campo Search. Esto debería mostrar un número de parte coincidente. Seleccione la parte y haga clic en OK:

Figura 4.33 – Diálogo Add Configuration Memory Device

7. Se le presentará un diálogo preguntando Do you want to program the configuration memory device now? Haga clic en OK.
8. Esto abrirá un diálogo Program Configuration Memory Device solicitando el nombre de archivo de configuración. Haga clic en el botón … a la derecha de Configuration file y seleccione C:/Projects/ArtyAdder/ArtyAdder.runs/impl_1/ARTY_ADDER.bin. Haga clic en OK:

Figura 4.34 – Diálogo Program Configuration Memory Device

9. El proceso de programación tomará varios segundos. Debería recibir un mensaje indicando éxito después de que el archivo haya sido programado en la memoria flash de la placa:

Figura 4.35 – Diálogo Program Flash complete

Después de esto, cada vez que cicla la alimentación de la placa, el programa del sumador de 4 bits se cargará y ejecutará. Tomará mucho tiempo cargar el programa con la configuración que usamos para carga de archivo de configuración. Para evitar esperar a que la FPGA cargue el programa, puede mejorar la velocidad de carga del archivo de configuración realizando los siguientes pasos:

1. Seleccione Open Synthesized Design en Flow Navigator.
2. En el menú principal de Vivado, seleccione Tools/Edit Device Properties….
3. En la pestaña General, establezca Enable Bitstream Compression en TRUE.
4. En la pestaña Configuration, establezca Configuration Rate (MHz) en 33, luego haga clic en OK.
5. Genere el bitstream nuevamente y programe la memoria flash como se describió. Deberá quitar el dispositivo de memoria de configuración y agregarlo de nuevo para mostrar la opción de reprogramación.
6. Cierre Hardware Manager.
7. Desconecte el cable USB de la placa Arty y vuelva a conectarlo. El programa debería comenzar a ejecutarse virtualmente instantáneo al encender.

Esta sección presentó un ejemplo de lógica combinacional simple interactuando con señales en los pines de E/S de la FPGA. La intención aquí ha sido familiarizarle con la suite de herramientas Vivado y demostrar cómo se usan las herramientas para realizar un ciclo completo de desarrollo FPGA.

Resumen

Este capítulo comenzó con una discusión sobre el uso efectivo de FPGAs en arquitecturas de sistemas embebidos en tiempo real y continuó con una descripción de dispositivos FPGA estándar y los componentes de bajo nivel que contienen. Se introdujo la gama de lenguajes de diseño FPGA, incluyendo HDLs, métodos de diagrama de bloques y lenguajes de programación de software populares como C/C++. Se presentó un esquema del proceso de desarrollo FPGA. El capítulo concluyó con un ejemplo completo de un ciclo de desarrollo FPGA, partiendo de una declaración de requisitos y terminando con un sistema funcional implementado en una placa de desarrollo FPGA de bajo costo.

Habiendo completado este capítulo, debería saber cómo las FPGAs pueden aplicarse efectivamente en arquitecturas de sistemas embebidos en tiempo real y entender los componentes dentro de un circuito integrado FPGA. Ha aprendido sobre los lenguajes de programación usados en el diseño de algoritmos FPGA, los pasos en el ciclo de desarrollo FPGA, y entiende la secuencia de pasos en el proceso de desarrollo FPGA.

El próximo capítulo ampliará el proceso de desarrollo FPGA para proporcionar un enfoque completo para arquitecturar sistemas embebidos en tiempo real que contengan FPGAs. También comenzará el desarrollo de un sistema embebido de alto rendimiento prototipo, un osciloscopio digital, que servirá de ejemplo para los siguientes capítulos.

Reimpreso con permiso de Packt Publishing. Copyright © 2021 Packt Publishing

---

Jim Ledin es CEO de Ledin Engineering, Inc. Jim es experto en diseño, desarrollo y prueba de software y hardware embebido. También es experto en evaluación de ciberseguridad y pruebas de penetración de sistemas embebidos. Tiene un B.S. en ingeniería aeroespacial de Iowa State University y un M.S. en ingeniería eléctrica y de computación de Georgia Institute of Technology. Jim es ingeniero eléctrico profesional registrado en California, Certified Information System Security Professional (CISSP), Certified Ethical Hacker (CEH), y Certified Penetration Tester (CPT).

---

Contenido relacionado

• Diseño embebido con FPGAs: Recursos de hardware
• Diseño embebido con FPGAs: Lenguajes de implementación
• Diseño embebido con FPGAs: Proceso de desarrollo
• Herramientas open-source ayudan a simplificar programación FPGA
• Implementación de algoritmos de punto flotante en FPGAs o ASICs
• Aprovechamiento de FPGAs para deep learning
• Herramientas de software migran código GPU a FPGAs para aplicaciones AI

Para más contenido de Embedded, suscríbete al boletín semanal de Embedded.