FPGA et logique reconfigurable¶

Quand un microcontrôleur manque de débit ou de déterminisme, et qu'un ASIC est hors budget, le FPGA occupe un espace unique : du silicium programmable capable de traiter des millions d'événements en parallèle, reconfigurable à la volée.

Architecture interne d'un FPGA¶

Un FPGA (Field-Programmable Gate Array) est une matrice de blocs logiques reconfigurables interconnectés par un réseau de routage programmable. Contrairement à un processeur qui exécute des instructions séquentiellement, un FPGA réalise des fonctions en logique combinatoire et séquentielle câblées — tout s'exécute en parallèle.

Les blocs fondamentaux¶

CLB (Configurable Logic Block) — ou LAB (Logic Array Block) chez Intel : contient des LUT (Look-Up Tables), des bascules D (flip-flops) et de la logique d'arithmétique rapide (carry chain). C'est l'unité de base de tout circuit implémenté.

LUT (Look-Up Table) : une LUT-4 est une table de vérité à 4 entrées implémentée en SRAM. Elle peut réaliser n'importe quelle fonction booléenne de 4 variables. Une LUT-6 (standard actuel) couvre 6 entrées.

IOB (Input/Output Block) : gère les signaux d'entrée/sortie avec registres, buffers de pilotage, support des standards (LVDS, LVCMOS, LVPECL), terminaisons, DDR.

Block RAM (BRAM) : blocs de mémoire SRAM dédiés de 18 ou 36 Kbits, à double port, utilisables en FIFO, ROM, RAM simple/dual-port. Évitent d'utiliser les LUT pour le stockage.

DSP Slices : multiplicateurs câblés (18×18 ou 27×18 bits) avec accumulateur, optimisés pour les filtres numériques, FFT, PID, corrélateurs. Bien plus efficaces que les LUT pour le calcul.

PLL / MMCM : synthèse d'horloge, multiplication/division de fréquence, déphasage précis.

Diagramme d'architecture FPGA simplifiée¶

graph TB
    subgraph FPGA
        subgraph "Fabric reconfigurable"
            CLB1["CLB\nLUT + FF\n+ carry"] --- INT["Interconnect\nréseau de routage\nprogrammable"]
            CLB2["CLB\nLUT + FF\n+ carry"] --- INT
            CLB3["CLB\nLUT + FF\n+ carry"] --- INT
            INT --- BRAM["Block RAM\n18/36 Kbits\ndual-port"]
            INT --- DSP["DSP Slice\nMult 18×18\n+ Accum"]
        end
        subgraph "I/O"
            IOB1["IOB\nLVDS / LVCMOS\nDDR registers"]
            IOB2["IOB\nLVDS / LVCMOS\nDDR registers"]
        end
        subgraph "Ressources fixes"
            PLL["PLL/MMCM\nSynthèse horloge"]
            SERDES["SERDES\nGbps I/O"]
        end
        INT --- IOB1
        INT --- IOB2
        INT --- PLL
        INT --- SERDES
    end
    CONFIG["Fichier bitstream\n(.bit / .sof)"] -.->|"Configuration\nau démarrage"| FPGA

SoC FPGA : processeur + logique programmable¶

Le SoC FPGA combine un cœur processeur dur (non reconfigurable) avec de la logique FPGA sur le même die. Cette combinaison est particulièrement pertinente pour l'IoT industriel : le processeur gère les couches hautes (Linux, pile réseau, interface utilisateur) pendant que la partie FPGA réalise le traitement temps réel en accélérateur matériel.

Xilinx Zynq-7000 / Zynq UltraScale+¶

La famille Zynq (AMD-Xilinx) intègre :

• PS (Processing System) : Cortex-A9 dual-core (Zynq-7000) ou Cortex-A53 quad-core (ZynqMP)
• PL (Programmable Logic) : fabric FPGA Artix-7 ou UltraScale+
• Interface PS↔PL : AXI4 haute performance (plusieurs Go/s de bande passante)

Zynq-7020 (Z-7020) :
  PS : Cortex-A9 dual @ 766 MHz, 1 Go DDR3
  PL : 85 000 CLB, 220 DSP slices, 4,9 Mbits BRAM
  Consommation : 1,5–2,5 W
  Prix : 15–40 € (volume)

Intel Cyclone V SoC¶

La famille Cyclone V SoC (Intel/Altera) offre un positionnement similaire avec Cortex-A9 dual-core et fabric FPGA. Elle est particulièrement répandue dans les applications vision industrielle et contrôle moteur.

Tableau comparatif : familles SoC FPGA pour IoT¶

FPGA vs MCU vs ASIC : quand choisir quoi ?¶

flowchart TD
    A[Besoin traitement\nspécialisé] --> B{Volume de\nproduction ?}
    B -- "> 100 000 / an" --> C{Modifications\naprès fabrication ?}
    C -- Non --> D[ASIC\nPerf max, coût NRE élevé\nPas de retour en arrière]
    C -- Oui --> E[FPGA en production\nou SoC FPGA]
    B -- "< 100 000 / an" --> F{Traitement\nparallèle requis ?}
    F -- "Oui — DSP, vision,\nprotocoles custom" --> G[FPGA ou SoC FPGA]
    F -- "Non — tâches\nséquentielles" --> H{Ressources CPU\nsuffisantes ?}
    H -- Oui --> I[MCU standard\nMoins cher, plus simple]
    H -- Non --> J[MCU haute perf\nCortex-M7 ou Cortex-A]

Tableau comparatif détaillé : FPGA vs MCU vs ASIC¶

Cas d'usage IoT industriel¶

Traitement du signal en temps réel¶

Un réseau de capteurs vibratoires sur une turbine nécessite d'échantillonner 32 voies à 200 kSa/s et d'appliquer une FFT 1024 points en temps réel sur chaque voie. Un MCU Cortex-M7 peut traiter 1–2 voies. Un FPGA Artix-7 traite les 32 voies en parallèle avec une latence de quelques microsecondes.

Vision industrielle embarquée¶

La détection de défauts sur ligne de production peut requérir l'analyse de 60 images/seconde à 1080p. Un FPGA implémente les algorithmes de convolution (sobel, canny) directement dans la logique câblée, avec un débit de pixels de plusieurs Gbps.

Protocoles de communication custom¶

Certains équipements industriels utilisent des protocoles propriétaires ou des variantes non standard (SERCOS III, EtherCAT slave, protocoles radio custom). Le FPGA implémente le contrôleur au niveau bit/symbole, là où un MCU ne peut pas tenir le timing.

Accélération cryptographique¶

AES-256 en software sur un Cortex-M4 : ~4 Mbps. Implémenté en FPGA (pipeline câblé) : > 1 Gbps. Pour les gateways IoT qui chiffrent des flux importants, la différence est rédhibitoire.

Langages et outils de développement FPGA¶

Développer pour FPGA n'est pas du développement logiciel classique — c'est de la description de matériel. Les langages HDL (Hardware Description Language) décrivent des circuits, pas des algorithmes séquentiels.

VHDL vs Verilog vs SystemVerilog¶

Le VHDL est le langage enseigné au CNAM (UE ELE106, ELE119) et dominant dans l'industrie française (aéronautique, défense, spatial).

Chaîne d'outils FPGA¶

flowchart LR
    HDL["Code HDL\n(VHDL / Verilog)"] --> SIM["Simulation\nfontionnelle\n(GHDL, ModelSim)"]
    SIM --> SYNTH["Synthèse\nlogique\n(Vivado, Quartus)"]
    SYNTH --> IMPL["Implémentation\n(Place & Route)"]
    IMPL --> BIT["Bitstream\n(.bit / .sof)"]
    BIT --> PROG["Programmation\nJTAG / SPI Flash"]
    PROG --> HW["FPGA cible"]
    IMPL --> TIMING["Rapport timing\nSetup/Hold\nWNS / TNS"]
    TIMING --> IMPL

Le rapport de timing est critique : si la contrainte de timing n'est pas respectée (WNS — Worst Negative Slack — négatif), le circuit peut fonctionner de manière aléatoire en conditions réelles (variations de température, tension). Un FPGA qui "fonctionne sur le bureau" avec un timing marginal tombera en production à 85 °C.

HLS : synthèse de haut niveau¶

Les outils HLS (High-Level Synthesis) comme Vitis HLS (Xilinx) ou Intel HLS Compiler permettent de synthétiser du C/C++ annoté en logique FPGA. Ils réduisent considérablement le temps de développement pour les algorithmes DSP et ML, au prix d'une moins bonne optimisation manuelle.

// Exemple Vitis HLS : filtre FIR 8 taps synthétisable en FPGA
#include "ap_fixed.h"
typedef ap_fixed<16,4> data_t;
typedef ap_fixed<32,8> acc_t;

void fir_filter(data_t x, data_t *y) {
    static data_t shift_reg[8] = {0};
    static const data_t coeffs[8] = {0.1, 0.15, 0.2, 0.05, 0.05, 0.2, 0.15, 0.1};

    #pragma HLS PIPELINE II=1   // Directive : pipeline avec initiation interval = 1 cycle
    acc_t acc = 0;
    for (int i = 7; i > 0; i--) {
        shift_reg[i] = shift_reg[i-1];
    }
    shift_reg[0] = x;
    for (int i = 0; i < 8; i++) {
        acc += shift_reg[i] * coeffs[i];
    }
    *y = (data_t)acc;
}

La directive #pragma HLS PIPELINE II=1 indique au synthétiseur de créer un pipeline capable d'accepter un nouvel échantillon à chaque cycle d'horloge — ce qui est impossible en logique séquentielle C pure.

Ce qu'il faut retenir¶

• Un FPGA réalise des fonctions en logique câblée parallèle — il ne "tourne" pas un programme, il est un circuit. Cette différence conceptuelle est fondamentale.
• Les SoC FPGA (Zynq, Cyclone V SoC) combinent le meilleur des deux mondes : Linux sur le processeur dur, traitement déterministe sur la partie FPGA. Ils sont la base des gateways industrielles haute performance.
• Le FPGA est justifié quand le MCU le plus puissant disponible n'a pas le débit ou le déterminisme requis, et que les volumes sont insuffisants pour amortir un ASIC.
• Le NRE d'un ASIC dépasse 500 k€ pour un nœud 28 nm — réservé aux volumes supérieurs à 100 000 unités/an avec des exigences fixes.
• L'énergie est le talon d'Achille du FPGA en contexte batterie : un FPGA consomme 0,5 à 4 W au minimum, ce qui le réserve aux applications alimentées sur secteur ou PoE.

Chapitre suivant : Gestion de l'énergie — comment dimensionner l'alimentation d'un nœud IoT pour des années d'autonomie.