nextpnr -- una herramienta portátil de colocación y enrutamiento para FPGA

nextpnr pretende ser una herramienta FOSS de colocación y enrutamiento para FPGA, independiente del fabricante y guiada por la temporización.

Actualmente, nextpnr soporta:

Dispositivos Lattice iCE40 compatibles con Project IceStorm
Dispositivos Lattice ECP5 compatibles con Project Trellis
Dispositivos Lattice Nexus compatibles con Project Oxide
Dispositivos Gowin LittleBee y Aurora V compatibles con Project Apicula
Dispositivos NanoXplore NG-Ultra compatibles con Project Beyond
Dispositivos Cologne Chip GateMate compatibles con Project Peppercorn
(experimental) dispositivos Cyclone V compatibles con Mistral
(experimental) dispositivos Lattice MachXO2 compatibles con Project Trellis
(experimental) dispositivos Xilinx serie 7 compatibles con Project X-Ray
(experimental) un back-end "genérico" para arquitecturas definidas por el usuario

Un breve artículo (académico) que describe el flujo Yosys+nextpnr se puede encontrar en arXiv.

Aquí se muestra una captura de pantalla de nextpnr para iCE40. Las instrucciones de compilación y las notas de inicio rápido se pueden encontrar a continuación.

Véase también:

Requisitos previos

Es necesario instalar los siguientes paquetes para compilar nextpnr, independientemente de la arquitectura seleccionada:

CMake 3.25 o posterior
Compilador moderno de C++17 (clang-format necesario para el desarrollo)
Python 3.5 o posterior, incluidas las bibliotecas de desarrollo (python3-dev en Ubuntu)
- Se requiere Python 3.9 o posterior para nextpnr-himbaechel
- en Windows, asegúrate de instalar la misma versión compatible con vcpkg
Bibliotecas Boost (libboost-dev libboost-filesystem-dev libboost-thread-dev libboost-program-options-dev libboost-iostreams-dev libboost-dev o libboost-all-dev en Ubuntu)
Eigen3 (libeigen3-dev en Ubuntu)
Yosys es necesario para sintetizar el diseño de demostración
Para compilar en Windows con MSVC, se recomienda el uso de vcpkg para la instalación de dependencias.
- Para compilaciones de 32 bits: vcpkg install boost-filesystem boost-program-options boost-thread eigen3
- Para compilaciones de 64 bits: vcpkg install boost-filesystem:x64-windows boost-program-options:x64-windows boost-thread:x64-windows eigen3:x64-windows
- Para compilaciones estáticas, añade -static a cada uno de los nombres de paquete. Por ejemplo, cambia eigen3:x64-windows a eigen3:x64-windows-static
- Una copia de Python que coincida con la versión en vcpkg (actualmente Python 3.6.4). Puedes descargar el archivo ZIP integrable y extraerlo. Puede que necesites extraer python36.zip, que está dentro del archivo ZIP integrable, a un nuevo directorio llamado "Lib".
Para compilar en macOS, se necesita la utilidad brew.
- Instala todos los paquetes necesarios brew install cmake python boost eigen

Primeros pasos

En primer lugar, ejecuta:

git submodule update --init --recursive

nextpnr-ice40

Para soporte de iCE40, instala Project IceStorm en /usr/local u otra ubicación, que debe pasarse como -DICESTORM_INSTALL_PREFIX=/usr a CMake. Luego compila e instala nextpnr-ice40 con los siguientes comandos:

mkdir -p build && cd build
cmake .. -DARCH=ice40
make -j$(nproc)
sudo make install

En Windows, puedes especificar las rutas explícitamente:

cmake . -B build -DARCH=ice40 -DICESTORM_INSTALL_PREFIX=C:/ProgramData/icestorm -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows -G "Visual Studio 15 2017 Win64" -DPython3_EXECUTABLE=C:/Python364/python.exe -DPython3_LIBRARY=C:/vcpkg/packages/python3_x64-windows/lib/python36.lib -DPython3_INCLUDE_DIR=C:/vcpkg/packages/python3_x64-windows/include/python3.6
cmake --build build --config Release

Para crear una compilación estática de release, cambia el triplet de destino de x64-windows a x64-windows-static y añade -DBUILD_STATIC=ON.

Un ejemplo sencillo que se ejecuta en la placa de desarrollo iCEstick se puede encontrar en ice40/examples/blinky/blinky.*. Ejemplo de uso:

cd ice40/examples/blinky
yosys -p 'synth_ice40 -top blinky -json blinky.json' blinky.v               # synthesize into blinky.json
nextpnr-ice40 --hx1k --json blinky.json --pcf blinky.pcf --asc blinky.asc   # run place and route
icepack blinky.asc blinky.bin                                               # generate binary bitstream file
iceprog blinky.bin                                                          # upload design to iCEstick

Ejecutar nextpnr en modo GUI (consulta a continuación las instrucciones para compilar nextpnr con soporte GUI):

nextpnr-ice40 --json blinky.json --pcf blinky.pcf --asc blinky.asc --gui

(Usa los botones de la barra de herramientas o la consola de comandos de Python para realizar acciones como empaquetar, colocar, enrutar y escribir archivos de salida).

nextpnr-ecp5

Para soporte de ECP5, instala Project Trellis en /usr/local u otra ubicación, que debe pasarse como -DTRELLIS_INSTALL_PREFIX=/usr/local a CMake. Luego compila e instala nextpnr-ecp5 con los siguientes comandos:

mkdir -p build && cd build
cmake .. -DARCH=ecp5 -DTRELLIS_INSTALL_PREFIX=/usr/local
make -j$(nproc)
sudo make install

Ejemplos del flujo ECP5 para una variedad de placas se pueden encontrar en los Ejemplos de Project Trellis.

nextpnr-nexus

Para soporte de Nexus, instala Project Oxide en $HOME/.cargo u otra ubicación, que debe pasarse como -DOXIDE_INSTALL_PREFIX=$HOME/.cargo a CMake. Luego compila e instala nextpnr-nexus con los siguientes comandos:

mkdir -p build && cd build
cmake .. -DARCH=nexus -DOXIDE_INSTALL_PREFIX=$HOME/.cargo
make -j$(nproc)
sudo make install

Ejemplos del flujo Nexus para una variedad de placas se pueden encontrar en los Ejemplos de Project Oxide.

nextpnr-mistral

Para soporte de Cyclone V, clona Mistral en $HOME/mistral u otra ubicación y pasa esta ruta como -DMISTRAL_ROOT=$HOME/mistral a CMake. Luego compila e instala nextpnr-mistral con los siguientes comandos:

mkdir -p build && cd build
cmake .. -DARCH=mistral -DMISTRAL_ROOT=$HOME/mistral
make -j$(nproc)
sudo make install

El soporte para Cyclone V es actualmente experimental y cuenta con pruebas limitadas. El backend está siendo sometido a una refactorización activa de su API, y su estructura, requisitos de compilación y puntos de integración pueden cambiar entre versiones.

nextpnr-generic

El target genérico permite ejecutar la colocación y el enrutamiento para arquitecturas personalizadas arbitrarias.

mkdir -p build && cd build
cmake .. -DARCH=generic
make -j$(nproc)
sudo make install

Un ejemplo de cómo usar el flujo genérico está en generic/examples. Consulta también la documentación de Generic Architecture.

nextpnr-himbaechel

El target himbaechel permite ejecutar la colocación y el enrutamiento para arquitecturas más grandes que comparten una estructura común.

gowin

Para soporte de Gowin, instala Project Apicula

mkdir -p build && cd build
cmake .. -DARCH="himbaechel" -DHIMBAECHEL_UARCH="gowin"
make -j$(nproc)
sudo make install

Ejemplos del flujo Gowin para una variedad de placas se pueden encontrar en los Ejemplos de Project Apicula.

ng-ultra

Para soporte de NanoXplore NG-Ultra, clona el repositorio Project Beyond DB

mkdir -p build && cd build
cmake .. -DARCH="himbaechel" -DHIMBAECHEL_UARCH="ng-ultra" -DHIMBAECHEL_PRJBEYOND_DB=/path/to/prjbeyond-db -DHIMBAECHEL_NGULTRA_DEVICES=ng-ultra
make -j$(nproc)
sudo make install

Ten en cuenta que la creación de bitstreams binarios requiere la herramienta Impulse de NanoXplore.

gatemate

Para soporte de Cologne Chip GateMate, clona Project Peppercorn

mkdir -p build && cd build
cmake .. -DARCH="himbaechel" -DHIMBAECHEL_UARCH="gatemate" -DHIMBAECHEL_PEPPERCORN_PATH=/path/to/prjpeppercorn
make -j$(nproc)
sudo make install

GUI

La GUI de nextpnr no se compila por defecto, para reducir el número de dependencias en una compilación estándar sin interfaz (headless). Para habilitarla, añade -DBUILD_GUI=ON a la línea de comandos de CMake y asegúrate de que Qt5/Qt6 y OpenGL estén disponibles:

Para Qt6:

En Ubuntu 22.04 LTS o posterior, instala qt6-base-dev
Para MSVC vcpkg, instala qt-base (32 bits) o qt-base:x64-windows (64 bits)
Para Homebrew, instala qt6 y añade qt6 al PATH: echo 'export PATH="/usr/local/opt/qt/bin:$PATH"' >> ~/.bash_profile ` - este cambio tiene efecto en la próxima sesión de terminal, así que vuelve a abrir la ventana de terminal antes de compilar

Para Qt5:

En Ubuntu 22.04 LTS, instala qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools
En otras versiones de Ubuntu, instala qt5-default
Para MSVC vcpkg, instala qt5-base (32 bits) o qt5-base:x64-windows (64 bits)
Para Homebrew, instala qt5 y añade qt5 al PATH: echo 'export PATH="/usr/local/opt/qt/bin:$PATH"' >> ~/.bash_profile ` - este cambio tiene efecto en la próxima sesión de terminal, así que vuelve a abrir la ventana de terminal antes de compilar

Múltiples arquitecturas

Para compilar nextpnr para varias arquitecturas a la vez, se puede usar una lista separada por punto y coma con -DARCH.

mkdir -p build && cd build
cmake .. -DARCH="ice40;ecp5"
make -j$(nproc)
sudo make install

Para compilar todas las arquitecturas estables disponibles, usa -DARCH=all. Para incluir arquitecturas experimentales (actualmente nexus), usa -DARCH=all+alpha.

Himbächel por microarquitectura

Para compilar un único ejecutable nextpnr-himbachel para cada una de las microarquitecturas compatibles, usa -DHIMBAECHEL_SPLIT.

mkdir -p build && cd build
cmake .. -DARCH="himbaechel" -DHIMBAECHEL_UARCH="gowin;ng-ultra"
make -j$(nproc)
sudo make install

En una compilación de este tipo, en lugar de un único binario nextpnr-himbaechel, se generan dos binarios: nextpnr-himbaechel-gowin y nextpnr-himbaechel-ng-ultra. Aunque se instalan juntos, cada microarquitectura es completamente independiente de la otra y solo necesita su correspondiente directorio de base de datos de chips .../share/himbaechel/<microarchitecture>/ para ejecutarse. La compilación dividida reduce el tamaño de los artefactos distribuidos individualmente (aunque el tamaño total aumenta) y permite la coinstalación de artefactos de diferentes versiones.

Compilación cruzada

Además de las bases de datos de chips, nextpnr requiere que la herramienta bba se compile para el sistema de compilación. Esta herramienta se puede compilar como un proyecto separado:

cd bba
cmake .
make

Esto creará un archivo bba-export.cmake. Proporciona la ruta a este archivo cuando compiles nextpnr de forma cruzada usando -DBBA_IMPORT=/path/to/bba-export.cmake.

Notas adicionales para compilar nextpnr

Lo siguiente ejecuta una compilación de depuración de la arquitectura iCE40 sin GUI, sin soporte de Python, sin el colocador analítico HeAP y solo con soporte HX1K:

mkdir -p build && cd build
cmake .. -DARCH=ice40 -DCMAKE_BUILD_TYPE=Debug -DBUILD_PYTHON=OFF -DICE40_DEVICES=1k
make -j$(nproc)

Para hacer una compilación estática de release para la arquitectura iCE40, usa lo siguiente:

mkdir -p build && cd build
cmake .. -DARCH=ice40 -DBUILD_PYTHON=OFF -DSTATIC_BUILD=ON
make -j$(nproc)

El solver del colocador HeAP puede usar opcionalmente OpenMP para acelerar diseños muy grandes. Habilítalo pasando -DUSE_OPENMP=yes a cmake (el soporte del compilador puede variar).

Puedes cambiar la ubicación donde se instalará nextpnr (normalmente será /usr/local por defecto) usando -DCMAKE_INSTALL_PREFIX=/install/prefix.

Notas para desarrolladores

Todo el código se formatea con clang-format de acuerdo con las reglas de estilo de .clang-format (basado en LLVM con mayores anchos de sangría y ajuste de llaves después de las clases).
Para formatear automáticamente todo el código fuente, ejecuta make clangformat.
Consulta la wiki para obtener documentación adicional sobre la API de arquitectura.

Grabar un vídeo

Para guardar una grabación en vídeo de la colocación y el enrutamiento, haz clic en el icono de grabación de la barra de herramientas, selecciona un directorio vacío donde se almacenarán los archivos de grabación y elige los fotogramas que se deben omitir.
Inicia manualmente todas las operaciones de PnR que desees
Vuelve a hacer clic en el icono de grabación para detener la grabación
Ve al directorio que contiene los archivos y ejecuta ffmpeg -f image2 -r 1 -i movie_%05d.png -c:v libx264 nextpnr.mp4

Pruebas

Para compilar también los binarios de prueba, usa -DBUILD_TESTS=ON y, después de make, ejecuta make test para ejecutarlos, o puedes ejecutar los binarios por separado.
Para usar sanitizadores de código, usa las opciones de cmake:
- -DSANITIZE_ADDRESS=ON
- -DSANITIZE_MEMORY=ON -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
- -DSANITIZE_THREAD=ON
- -DSANITIZE_UNDEFINED=ON
Ejemplo de ejecución con valgrind: valgrind --leak-check=yes --tool=memcheck ./nextpnr-ice40 --json ice40/blinky.json
Para ejecutar las pruebas con cobertura de código, usa -DBUILD_TESTS=ON -DCOVERAGE y, después de make, ejecuta make ice40-coverage
Después, abre ice40-coverage/index.html en tu navegador para ver el informe de cobertura
Ten en cuenta que se necesita lcov para generar los informes

nextpnr nextpnr-0.11

Categorías