Développement FPGA¶

Programmer du silicium reconfigurable — quand le logiciel ne peut pas atteindre la latence nanoseconde ou le parallélisme requis par l'application.

Quand choisir un FPGA ?¶

Un FPGA (Field-Programmable Gate Array) n'est pas un processeur plus rapide — c'est un paradigme de calcul différent. Là où un MCU exécute des instructions séquentiellement, un FPGA exécute des blocs logiques en parallèle, câblés dans le silicium au moment de la configuration.

Cas d'usage industriels :

• Traitement de signal temps réel : filtrage FIR/IIR à haute fréquence d'échantillonnage (ADC 250 MHz), FFT temps réel.
• Interface matérielle custom : protocoles propriétaires, timing précis à la nanoseconde (encodeurs haute résolution, Ethernet industriel EtherCAT).
• Vision industrielle : prétraitement d'image (binarisation, convolution) avant envoi au CPU.
• Systèmes de contrôle ultra-rapides : boucles de régulation à 1 MHz impossibles sur MCU.
• Prototypage ASIC : simuler un circuit intégré avant la fabrication.

Les FPGA courants en IoT industriel : Xilinx (AMD) Artix-7, Zynq-7000 (FPGA + dual Cortex-A9), Intel (Altera) Cyclone V, Lattice ECP5.

HDL — décrire du matériel, pas de la logique¶

Les HDL (Hardware Description Languages) décrivent le comportement et la structure de circuits numériques. Le code HDL ne s'exécute pas — il se synthétise en portes logiques, bascules et blocs mémoire.

VHDL — Ada du hardware¶

VHDL (VHSIC Hardware Description Language) est fortement typé, verbeux, et largement utilisé dans les secteurs défense et aérospatial où la lisibilité et la traçabilité sont prioritaires.

-- Filtre passe-bas simple en VHDL (premier ordre)
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity filtre_pb is
    generic (COEF_ALPHA : integer := 16); -- alpha = 1/16
    port (
        clk     : in  std_logic;
        reset_n : in  std_logic;
        x_in    : in  signed(15 downto 0);
        y_out   : out signed(15 downto 0)
    );
end entity;

architecture rtl of filtre_pb is
    signal acc : signed(31 downto 0) := (others => '0');
begin
    process(clk, reset_n)
    begin
        if reset_n = '0' then
            acc <= (others => '0');
        elsif rising_edge(clk) then
            -- y[n] = y[n-1] + (x[n] - y[n-1]) / alpha
            acc <= acc + resize(x_in, 32) - (acc / COEF_ALPHA);
        end if;
    end process;
    y_out <= acc(27 downto 12); -- normalisation
end architecture;

Verilog / SystemVerilog — la syntaxe C du hardware¶

Verilog est plus concis que VHDL, avec une syntaxe rappelant le C. SystemVerilog ajoute des constructions modernes (interfaces, packages, assertions) et est le standard de facto pour la vérification (UVM).

// Même filtre en Verilog
module filtre_pb #(
    parameter COEF_ALPHA = 16
)(
    input  wire        clk,
    input  wire        reset_n,
    input  wire signed [15:0] x_in,
    output reg  signed [15:0] y_out
);
    reg signed [31:0] acc;
    always @(posedge clk or negedge reset_n) begin
        if (!reset_n)
            acc <= 0;
        else
            acc <= acc + x_in - (acc / COEF_ALPHA);
    end
    assign y_out = acc[27:12];
endmodule

Tableau comparatif HDL¶

HLS — C/C++ vers RTL¶

La Synthèse de Haut Niveau (HLS, High-Level Synthesis) traduit du code C/C++ en description RTL (Register Transfer Level) synthétisable. Elle supprime le besoin d'écrire du HDL pour les algorithmes de traitement.

Vivado HLS / Vitis HLS (AMD/Xilinx)¶

// Filtre FIR en C++ pour Vitis HLS
#include "ap_int.h"

typedef ap_int<16> data_t;
typedef ap_int<32> acc_t;

const int N_TAPS = 16;
const data_t coefs[N_TAPS] = {1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1};

void fir_filter(data_t x_in, data_t *y_out) {
    #pragma HLS PIPELINE II=1     // latence d'initiation = 1 cycle
    static data_t shift_reg[N_TAPS];
    #pragma HLS ARRAY_PARTITION variable=shift_reg complete

    acc_t acc = 0;
    // Décalage du registre à décalage
    for (int i = N_TAPS-1; i > 0; i--) {
        #pragma HLS UNROLL
        shift_reg[i] = shift_reg[i-1];
    }
    shift_reg[0] = x_in;
    // Calcul du produit scalaire
    for (int i = 0; i < N_TAPS; i++) {
        #pragma HLS UNROLL
        acc += coefs[i] * shift_reg[i];
    }
    *y_out = acc >> 4; // normalisation
}

Les pragmas HLS guident la synthèse : PIPELINE déroule les boucles temporellement, UNROLL les parallélise spatalement, ARRAY_PARTITION distribue les tableaux sur plusieurs banques mémoire pour l'accès parallèle.

Avantages HLS :

• Développement 5 à 10 fois plus rapide que le HDL manuel.
• Exploration de l'espace de conception (latence vs ressources) par modification des pragmas.
• Réutilisation des algorithmes existants en C.

Limites HLS :

• Le RTL généré n'est pas optimal en densité — un expert HDL peut souvent réduire les ressources de 20 à 40 %.
• Difficile à utiliser pour les interfaces matérielles complexes (contrôleurs de protocoles, gestion fine du timing).
• Debugging moins direct que le RTL.

Toolchains FPGA¶

La toolchain open source (Yosys + nextpnr + OpenFPGALoader) est viable pour les Lattice ECP5 et iCE40 — des choix populaires en maker et en prototypage. Pour la production industrielle, les toolchains propriétaires de Xilinx ou Intel restent incontournables.

Co-design hardware/software¶

Le co-design HW/SW tire le meilleur des deux mondes : un processeur soft implémenté dans la logique FPGA exécute le firmware, tandis que la logique custom accélère les parties temps-réel critiques.

MicroBlaze (Xilinx) : processeur 32 bits RISC configurable en logique Xilinx. Supporte Linux avec MMU optionnel. Utilisé dans les Artix-7 et Kintex-7.

Nios II (Intel) : équivalent Intel/Altera. Moins utilise depuis l'arrivée des SoC Cyclone V avec Cortex-A9 hard.

Zynq-7000 / Zynq UltraScale+ : combinaison d'un processeur Cortex-A9 ou Cortex-A53 hardcodé (Processing System, PS) et de logique programmable (PL). Le PS et la PL communiquent via AXI4 — bus haut débit standardisé ARM AMBA.

graph LR
    subgraph Zynq7000["Zynq-7000"]
        subgraph PS["PS"]
            A1["Cortex-A9<br/>Linux<br/>Driver DMA"]
        end
        subgraph PL["PL"]
            B1["AXI Périph.<br/>FIR Filter IP<br/>Custom Protocol"]
        end
        A1 <-->|AXI4| B1
    end

IP Cores — la réutilisabilité en FPGA¶

Un IP core (Intellectual Property core) est un bloc de logique préconçu, testé et paramétrable. Les toolchains intègrent des centaines d'IP : UART, SPI, I2C, Ethernet MAC, PCIe, DMA, FFT, FIR, PLL.

Workflow d'intégration d'un IP FFT Vivado :

1. Ouvrir l'IP Catalog dans Vivado.
2. Configurer l'IP FFT : taille (1024 points), précision (18 bits fixed-point), architecture (pipelined streaming).
3. Générer l'IP — Vivado produit le HDL et les contraintes.
4. Connecter via AXI4-Stream au reste du design.
5. Simulation du comportement avant synthèse (co-simulation MATLAB/Simulink possible).

Workflow FPGA complet¶

flowchart TD
    A[Design HDL\nVHDL / Verilog\nou HLS C++] --> B[Simulation\nfunctionnelle\nGHDL / Icarus / ModelSim]
    B --> C{Tests OK ?}
    C -- Non --> A
    C -- Oui --> D[Synthèse\nYosys / Vivado\nportes logiques]
    D --> E[Implémentation\nPlace & Route\nnextpnr / Vivado]
    E --> F[Timing Analysis\nsetup/hold, slack]
    F --> G{Timing OK ?}
    G -- Non --> H[Optimisations\ncontraintes, pipeline]
    H --> D
    G -- Oui --> I[Génération\nBitstream .bit]
    I --> J[Flash FPGA\nJTAG ou SPI Flash]
    J --> K[Validation\nsur cible réelle]

    style A fill:#2d4a6e,color:#fff
    style K fill:#1a6e3a,color:#fff
    style C fill:#6e3a1a,color:#fff
    style G fill:#6e3a1a,color:#fff

Timing analysis : après le place & route, l'outil vérifie que les signaux se propagent assez vite entre bascules pour respecter la fréquence d'horloge cible. Un slack négatif signifie une violation de timing — le circuit ne fonctionnera pas de manière fiable.

Filtre FIR en VHDL — description fonctionnelle¶

Un filtre FIR (Finite Impulse Response) à N coefficients calcule une convolution discrète :

y[n] = Σ(k=0 à N-1) h[k] * x[n-k]

L'implémentation FPGA optimale utilise :

1. Un registre à décalage de N éléments, chargé à chaque échantillon.
2. Un tableau de multiplicateurs parallèles (un par coefficient).
3. Un arbre d'addition (adder tree) pour sommer les produits en O(log N) cycles.

Sur un FPGA Artix-7, un filtre FIR 64 taps à 16 bits tourne à 250 MHz, traitant 250 millions d'échantillons par seconde — impossible sur un MCU.

Ce qu'il faut retenir¶

• Un FPGA n'est pas un processeur rapide — c'est un calcul parallèle câblé. Choisir FPGA uniquement quand le parallélisme ou la latence nanoseconde est requise.
• VHDL est le standard défense/aéro ; Verilog domine les semi-conducteurs — les deux sont synthétisables sur toutes les toolchains majeures.
• HLS accélère le développement algorithmique mais ne remplace pas le HDL pour les interfaces matérielles critiques.
• Les SoC Zynq (Cortex-A + FPGA) sont le compromis idéal pour les applications mixtes HW/SW.
• Le timing analysis est le juge de paix — un design qui ne respecte pas les contraintes de timing doit être pipeliné.

Chapitre suivant : Debug et instrumentation — JTAG, SWD, oscilloscope et profiling pour trouver les bugs qui ne se reproduisent pas en simulation.