Systèmes embarqués (FPGA) — Résumé débutant (Parties 1 à 6)

Version enrichie : explications pas à pas, analogies, exemples, mind maps claires

Comment utiliser ce document (2 minutes)

Astuce
Lisez chaque section dans l’ordre : (1) Ce que c’est → (2) Pourquoi → (3) Exemple concret →
(4) À retenir. Les boîtes Exemple, Astuce, Erreur fréquente vous aident à aller à l’essentiel.

Partie 1 — Introduction aux systèmes embarqués

Idée clé
Un système embarqué (SE) = matériel + logiciel conçus ensemble pour réaliser une mission
précise sous contraintes : temps réel, énergie, coût, fiabilité.

1) Ce que c’est (débutant)

Un SE se trouve dans une voiture (ABS, airbag), un téléphone, une machine à laver, un capteur
IoT. Il lit des capteurs, décide dans un calculateur, puis agit via des actionneurs.

2) Pourquoi on utilise des bus (CAN) ?

Exemple

Au lieu d’avoir un câble par capteur, on partage un même câble (le bus) avec des trames numérotées.
⇒ Moins de câbles, moins de pannes, plus léger, plus facile à diagnostiquer.

3) Chaîne d’information (vue simple)

Capteurs Bus CAN/LIN Calculateur (ECU) Consigne Actionneurs

(mesures) Traitement & Décision (commande)

4) À retenir (débutant)
Mémo
— Un SE n’est pas un PC : il fait une tâche bien définie, souvent en temps réel.
— Le multiplexage (CAN) permet à plusieurs ECU de partager le même câble.

1
Mind map claire — Vue d’ensemble (débutant)

CAN
Fiabilité Coût
LIN

Énergie

Ethernet Réseaux Contraintes

Temps
réel

Systèmes
Embarqués

Auto FPGA

Applications Technos

Médical GPU

IoT Industrie CPU/µC DSP

Partie 2 — Temps réel, RTOS & Codesign

1) Temps réel (TR) = respect des délais
Idée clé
TR dur : rater la deadline met en danger la fonction (ex. airbag). TR mou : un retard dégrade
seulement la qualité (ex. musique qui grésille).

Exemple
Si un capteur fournit une mesure toutes les 10 ms, alors acquisition + calcul + sortie doivent
durer < 10 ms (marge incluse).

Erreur fréquente
Ne pas confondre rapide et déterministe. Un PC peut être très rapide mais non garanti à 10 ms à
tous les coups.

2) RTOS : pourquoi en SE ?
Mémo
Un RTOS garantit des délais bornés : ⇒ ordonnanceur (priorités), timers, interruptions, IPC
(sémaphores, files), drivers.

2
3) Codesign HW/SW (approche A3 )
Idée clé
On conçoit en même temps l’algorithme (logiciel) et l’architecture (matériel) pour placer le bon
calcul au bon endroit (CPU, µC, DSP, GPU, FPGA).

Mind map claire — Temps réel & RTOS

HW Interruptions
& SW
Timers

Partition

Codesign RTOS Priorités

Temps
réel

TR dur TR mou

ABS Vidéo

Airbag Audio

Partie 3 — CPU & notions de performance

1) CPU : blocs principaux
Mémo
ALU (entiers/logique), FPU (flottants), SIMD (même instruction, plusieurs données), banque de
registres, cache, bus.

2) Pipeline (vue chrono débutant)

IF ID EX MEM WB
(Fetch) (Decode) (ALU/FPU) (Mémoire) (Écriture)

Exemple
Sans aléas, une instruction entre au cycle i et termine à i + 4. Pour n instructions : Ncycles = n + 4,
CPI ≈ 1 quand n est grand.

3
3) Formules de performance (à mémoriser)
Mémo
Ncycles Ncycles
Tcycle = f1 , CPI = Ninstr , IPC = 1
CPI , Texec = f .

Partie 4 — Microcontrôleurs (µC) & DSP

1) Microcontrôleur = tout-en-un
Idée clé
Un µC regroupe CPU + mémoires (Flash, SRAM, EEPROM) + périphériques (ADC/DAC,
timers, UART/SPI/I2 C, CAN, PWM, watchdog) dans un seul boîtier.

Exemple

Un µC 32 bits (ARM Cortex-M) pilote un moteur DC : ADC lit la vitesse, PWM commande le pont
H, timer règle la période d’échantillonnage.

2) DSP = spécialiste du signal

Mémo
DSP : MAC rapides, adressage circulaire, DMA, buffers double-tampon. Idéal pour audio,
radar, vision, télécoms.

4
Mind map claire — CPU vs µC vs DSP

Filtres

FFT/Conv. MAC/DMA

DSP

UART/SPI/I2 C/CAN

Timers/PWM

Calcul
µC
embarqué
ADC/DAC

Flash/SRAM

CPU

ALU/FPU Pipeline

SIMD

Partie 5 — GPU & FLOPS

1) GPU : pourquoi ça va vite ?
Idée clé
Le GPU possède beaucoup d’unités simples qui travaillent en parallèle : idéal pour la même
opération sur beaucoup de données (images, tenseurs).

Mémo
Hiérarchie mémoire : globale (grande mais lente), partagée (petite mais proche), registres (très
proches).

2) FLOPS : mesurer la puissance flottante

Exemple

Si un cœur effectue 8 FLOP/cycle à 3 GHz : 8 × 3 = 24 GFLOPS par cœur (théorique).

5
Mind map claire — Accélération GPU

HPC
Latence
Vision/IA

Transferts

Limites Usages 3D/Video

GPU

Parallélisme Mémoire Registres

Unités
nom-
breuses
Partagée
Débit
élevé Globale

Partie 6 — FPGA & Systèmes hétérogènes

1) FPGA : l’idée en une phrase
Idée clé
Un FPGA est une matrice de blocs logiques et d’interconnexions que l’on reprogramme pour
créer son propre matériel : latence très faible, IO sur mesure.

2) Quand choisir GPU vs FPGA (débutant)

GPU FPGA
Forces Débit massif, dev rapide (CUDA/OpenCL) Forces Latence très faible, IO personnalisées, perf/-
Watt
Idéal Vision/IA, vidéo, calcul scientifiques Idéal Interfaces capteurs rapides, traitements dé-
terministes
Limites Latence, transferts mémoire Limites Dev HDL/HLS plus complexe

3) Systèmes hétérogènes : le bon mix

Exemple

Pipeline caméra : µC (gestion, IO bas niveau) + FPGA (prétraitements temps réel) + GPU
(détection IA) + CPU (logique applicative, réseau).

6
Mind map claire — Écosystème des accélérateurs

FLOPS
Massif
parallèle

CLB/Routage
GPU
IO temps
réel
FPGA

Filtres/FFT

Accélérateurs DSP
MAC/DMA

CPU
ALU/FPU
Multi-CPU
SIMD

Caches/NUMA
Threads

Exercices guidés (débutant)

1. TR : Citez 1 exemple TR dur et 1 TR mou dans l’auto. Justifiez le choix dur/mou.
2. CPI/IPC : À f = 2,0 GHz, Ninstr = 109 et CPI = 1,2. Calculez Ncycles puis Texec .
3. µC vs DSP : Pour un filtre audio 48 kHz, pourquoi un DSP peut être préférable ?
4. GPU vs FPGA : Quelle solution pour une détection d’objets vs une interface LIDAR à 1 µs de latence ?

Glossaire (10 mots à connaître)

Terme Sens (débutant)

Capteur Composant qui mesure (température, vitesse, position, . . .)
Actionneur Composant qui agit (moteur, électrovanne, LED, . . .)
ECU Calculateur qui lit les capteurs et commande les actionneurs
Bus CAN Câble partagé par plusieurs modules qui s’envoient des trames
RTOS Système d’exploitation qui garantit des délais
CPI/IPC Mesures d’efficacité du CPU (cycles/instruction, instruction/cycle)
µC Microcontrôleur tout-en-un (CPU+mémoire+périphériques)
DSP Processeur spécialisé traitement du signal
GPU Processeur très parallèle pour gros volumes de données
FPGA Puce reconfigurable pour créer du matériel sur mesure

Document pédagogique enrichi pour débutants : explications pas à pas, exemples concrets et mind maps simplifiées.

7
 Chapitre II — Circuits programmables & Architecture FPGA
Résumé pédagogique (autonome) : notions, architectures, flux CAO, mini-exercices

1) Panorama des circuits logiques (idées essentielles)

— Circuits standards (non modifiables) : microprocesseurs (CPU, GPU), microcontrôleurs
(µC), mémoires, ASSP (Application Specific Standard Product).
— Circuits spécifiques à une application : ASIC (circuit sur mesure : performance/coût de
volume), circuits programmables (PAL/EPLD/FPGA) reconfigurables après fabrication.
Mémo
FPGA = Field Programmable Gate Array : réseau de blocs logiques configurables (CLB)
interconnectés, + blocs E/S en périphérie, reprogrammable pour changer la fonction.

2) Technologies d’interconnexion (configurer la puce)

— Anti-fusible (one-time) : on « perce » l’oxyde ⇒ liaison permanente faible résistance. Avantages :
faible surface, robustesse ; Limite : non reconfigurable.
— Fusible/diode (PROM, PAL) (one-time) : on claque le fusible pour casser une liaison.
— SRAM (FPGA modernes) : configuration stockée en cellules SRAM ⇒ reprogrammable
à l’infini ; nécessite de recharger la configuration au power-on (mémoire externe/Flash).
Exemple
Pourquoi le coût unitaire FPGA est favorable en petite série ? Pas de masques ni de coûts
NRE d’ASIC ; en très grand volume, l’ASIC l’emporte (coût/puissance/aire optimisés).

3) Architecture FPGA (vue claire)

— CLB : contiennent des LUT (Look-Up Tables) réalisant des fonctions logiques (ex. LUT à k
entrées), des bascules (FF) et parfois des ressources additionnelles.
— Routage programmable : réseau d’interconnexions (commutateurs) pour relier LUT/FF.
— IOB : blocs d’entrées/sorties autour de la matrice (standards électriques, DDR, etc.).
— Clustering : plusieurs BLE (Basic Logic Elements) groupés dans un cluster de CLB pour
efficacité locale (routage court).

Commutateurs
LUT k-entrées Bascules (FF)
(routage)

IOB (E/S)

Mémo
Une LUT implémente n’importe quelle fonction booléenne de k entrées via une petite mémoire
(table de vérité). Exemple : LUT-4 peut réaliser une porte AND à 4 entrées.

1
4) Mind map — Famille & techno (vue d’ensemble)

Anti-
IOB
fusible
Fusible Routage

SRAM Config FPGA CLB/LUT/FF

Circuits
logiques

CPU/µC Standards Spécifiques

Programmables

Mémoires
ASIC
ASSP

5) Flux logiciel (CAO) — de l’HDL au bitstream

1. Description HDL/HLS : VHDL/Verilog (RTL) ou HLS (C/C++, Matlab HDL Coder,
OpenCL/CUDA pour cible adaptée).
2. Synthèse logique : RTL → réseau booléen (portes, FF) → netlist techno (librairie LUT/FF).
3. Mapping (cartographie) : transformation en k-LUT + FF compatibles FPGA.
4. Clustering : regroupement des BLE/CLB pour minimiser le routage local.
5. Placement : assigner chaque (C)LB/IOB à un emplacement physique.
6. Routage : calculer les chemins d’interconnexion (commutateurs) pour respecter délais/aire.
7. Génération du bitstream : fichier binaire qui programme les SRAM de config..
8. Configuration de la carte : bitstream chargé (ex. Flash externe → SRAM interne au power-on).
Mémo
Le timing (délais) est validé après placement/routage. On boucle si nécessaire jusqu’au respect
des contraintes (fréquence, latences d’E/S, etc.).

2
6) Mind map — Flux FPGA (du code au silicium)

Routage Placement

Place/Route

Config.
VHDL/Verilog FF
SRAM

HDL/HLS
Flux Mapping
Bitstream
FPGA
C/C++/Matlab
Power-on k-LUT

Synthèse

RTL →
Timing
Netlist

7) Mini-exercices (avec pistes de solution)

1. FPGA vs ASIC (coût) — Expliquez pourquoi FPGA est préférable en petite série, alors
que l’ASIC devient avantageux en grande série.
Piste : coûts fixes (masques, NRE), délai de mise sur le marché, reconfigurabilité.
2. Technos d’interconnexion — Citez un avantage et une limite pour anti-fusible, fusible,
SRAM.
Piste : reprogrammation, robustesse, besoin de mémoire externe, one-time vs multi-time.
3. Flux CAO — Classez Mapping, Routage, Placement, Synthèse dans l’ordre et donnez pour
chacun un objectif.
Piste : voir section 5.

3
8) À retenir (checklist)

1. FPGA = CLB/LUT/FF + routage + IOB, reprogrammable (SRAM).

2. Les technos d’interconnexion (anti-fusible, fusible, SRAM) conditionnent reconfigura-
bilité et flux de config.
3. Flux CAO : HDL/HLS → Synthèse → Mapping → Clustering → Placement → Routage
→ Bitstream → Configuration.

4
 Chapitre III — VHDL : Introduction & concepts de base
Résumé pédagogique autonome : unités VHDL, signaux/variables, types, opérateurs, styles d’architecture

1) Introduction rapide au VHDL

Idée clé
VHDL est un langage de description matérielle (HDL) pour décrire, simuler et
synthétiser des circuits numériques. Il est standardisé IEEE (1076-1987, 1076-1993, 1076.6-
1999 pour la synthèse RTL).

— Né dans les années 80 (DoD américain) pour réutiliser et réduire les coûts de conception.
— Indépendant des fournisseurs (outil-agnostique), adopté dans la CAO (Quartus, ISE/Vivado,
. . .).
— Deux familles d’outils : HDL (VHDL/Verilog) et HLS (C/C++/OpenCL → HDL).

2) Unité de conception : library/use, entity, architecture

Mémo
Une unité VHDL = bibliothèques/paquetages + entité (interface E/S) + architecture
(fonctionnement).

Bibliothèques/paquetages (indispensable).

library IEEE;
use IEEE.std_logic_1164.all; -- types std_logic, std_logic_vector, opérateurs logiques

Entité = interface (ports). Déclare noms, modes et types des E/S.

Mode Sens et usage

in Lecture depuis l’extérieur (jamais écrit par l’entité).
out Écrit par l’entité (non relu par elle).
buffer Écrit et relu par l’entité (cas particuliers).
inout Bidirectionnel (bus tri-état, lignes partagées).

Architecture = comportement interne. Plusieurs styles synthétisables :

— Flot de données (concurrent) : with..select, when..else.
— Comportemental (séquentiel dans un process) : if/case/loop.
— Structurel : instanciation et interconnexion de sous-modules (hiérarchie).
— Automates (FSM) : états/transitions (synchrone sur clock).

1
3) Exemples minimaux (synthétisables)
Exemple (synthétisable)

Multiplexeur 8→1 (entité + architecture flot de données).

library IEEE;
use IEEE.std_logic_1164.all;

entity MUX8to1 is
port(
Sel : in std_logic_vector(2 downto 0); -- MSB..LSB
A,B,C,D,E,F,G,H : in std_logic;
Y : out std_logic
);
end MUX8to1;

architecture dataflow of MUX8to1 is

begin
with Sel select
Y <= A when "000",
B when "001",
C when "010",
D when "011",
E when "100",
F when "101",
G when "110",
H when "111";
end dataflow;

2
 Exemple (synthétisable)

Process séquentiel (synchrone) : additionneur 8 bits avec reset.

library IEEE;
use IEEE.std_logic_1164.all;

entity adder8 is
port( clk, rst : in std_logic;
A, B : in std_logic_vector(7 downto 0);
S : out std_logic_vector(7 downto 0) );
end adder8;

architecture rtl of adder8 is

signal rS : std_logic_vector(7 downto 0);
begin
S <= rS; -- sortie liée au registre
process(clk)
begin
if rising_edge(clk) then
if rst=’1’ then
rS <= (others => ’0’);
else
rS <= std_logic_vector(unsigned(A) + unsigned(B));
end if;
end if;
end process;
end rtl;

4) Signaux <= vs variables :=

Mémo
Signal = « fil » matériel (monde hard), affectation <= (événement), visible en dehors du
process. Variable = stockage local (monde soft), affectation := immédiate dans le process,
non visible hors process.

Attention
Dans un process, les affectations <= sont consolidées à la fin du delta-cycle (ordre non
séquentiel), alors que := est immédiat.

5) Types courants : std_logic, std_logic_vector

— bit/bit_vector : 2 états (’0’/’1’) → trop limité en pratique.
— std_logic : 9 états (U,X,0,1,Z,W,L,H,-) normalisés IEEE std_logic_1164.
— std_logic_vector : tableau de std_logic, indexé (MSB downto LSB).

Littéraux utiles.

S1 <= ’0’; -- bit

V3 <= "001"; -- binaire (vecteur 3 bits)

3
V8 <= x"A5"; -- hexadécimal
V8 <= o"726"; -- octal

6) Opérateurs (aperçu synthèse)

— Logiques : not, and, or, nand, nor, xor, xnor
— Relationnels : =, /=, <, <=, >, >=
— Concaténation : & (ex. Y <= A & B;)
— Décalages/rotations : sll, srl, sla, sra, rol, ror
— Arithmétique sur vecteurs non signés/signés via numeric_std (ex. unsigned, signed)

7) Styles d’architecture (concurrent vs séquentiel)

— Concurrent (flot de données) : toutes les affectations s’exécutent « en parallèle ». Ex. with..select,
when..else.
— Séquentiel dans un process (souvent synchrone avec clock) : if/case/loop ; idéal pour
FSM.
— Structurel : assemblage de composants (instanciations).

8) Mind map — Unités & sémantique VHDL

États Séquentiel

Transitions Concurrent

FSM Sémantique

VHDL

library/use Unités Styles Structurel

entity Process
Flot
architecture
données

4
9) Mind map — Objets, modes, types

logiques
std_logic_vector
arithm.

std_logic

décalages Opérateurs Types

Objets

in/out Ports Classes constante

buffer variable

inout signal

10) Mini-exercices (avec pistes)

1. Entité & architecture : Décrivez une entity AOI (AND-OR-Invert) à 3 entrées, puis écrivez
une architecture flot de données.
2. Signal vs variable : Dans un process, montrez la différence entre <= et := avec deux additions
successives.
3. Vecteurs : Déclarez V: std_logic_vector(7 downto 0) et affectez la valeur hex x"A5" ; quel
est le MSB ?
4. MUX 4→1 : Écrivez une version comportementale (process + case) du MUX.

11) À retenir (checklist)

1. VHDL = HDL pour décrire/simuler/synthétiser des circuits numériques (IEEE 1076).

2. Unité = library/use + entity (interface) + architecture (fonctionnement).
3. Concurrent (flot de données) vs séquentiel (process synchrone) : bien distinguer.
4. Signals (<=) vs variables (:=) : sémantique différente dans un process.
5. Types pratiques : std_logic, std_logic_vector (IEEE std_logic_1164), littéraux bin/-
hex/oct.

5
 Chapitre V — VHDL : Description procédurale
Résumé autonome : process, if/elsif/else, case, wait, com. inter-processus, attributs de tableaux, exos

1) Instruction process : lier l’algorithme au temps

Idée clé
Un process est une instruction concurrente qui décrit séquentiellement (comme un algorithme)
le comportement d’une partie du circuit. Indispensable pour la logique séquentielle (bascules,
FSM).

— Déclenchement : par liste de sensibilité process(A,B,clk) ou par instructions wait (ne

jamais mélanger les deux dans le même process).
— Exécution : à chaque événement sur un signal sensible, les instructions du process s’exécutent
dans l’ordre ; les affectations aux signaux sont prises en compte à la fin du process (delta-cycle).
— Variables : locales au process, affectées immédiatement (:=), non visibles en dehors.
Exemple (synthétisable)
Process combinatoire (liste de sensibilité complète) :
\begin{verbatim}
process(A,B,SEL)
begin
if SEL=’0’ then
Y <= A and B;
else
Y <= A or B;
end if;
end process;
\end{verbatim}

Exemple (synthétisable)
Process synchrone (front montant) avec reset asynchrone :
\begin{verbatim}
process(clk, rst_n)
begin
if rst_n=’0’ then
Q <= ’0’;
elsif rising_edge(clk) then
Q <= D;
end if;
end process;
\end{verbatim}

2) Instruction conditionnelle if/elsif/else

Mémo
if en séquentiel (dans un process) — utile pour la logique combinatoire ou séquentielle.
Attention aux branches non couvertes (risque de latch non souhaité).

Exemple (synthétisable)
Détecteur de priorité (P2 > P1 > P0) version séquentielle :
\begin{verbatim}
process(P2,P1,P0)

1
 begin
if P2=’1’ then Y <= "10";
elsif P1=’1’ then Y <= "01";
elsif P0=’1’ then Y <= "00";
else Y <= "00";
end if;
end process;
\end{verbatim}

3) Instruction de choix case

Idée clé
case sélectionne un unique chemin selon la valeur d’une expression (typiquement un vecteur ou
entier). Plus lisible qu’une cascade de if pour MUX/décodeurs.

Exemple (synthétisable)
Multiplexeur 4$\to$1 (séquentiel dans un process) :
\begin{verbatim}
process(SEL,A,B,C,D)
begin
case SEL is
when "00" => Y <= A;
when "01" => Y <= B;
when "10" => Y <= C;
when others => Y <= D;
end case;
end process;
\end{verbatim}

4) wait : ON / UNTIL / FOR (simulation et styles codage)

Mémo
wait est séquentiel et incompatible avec une liste de sensibilité dans le même process. Très
utile en testbench ; en synthèse, privilégier rising_edge(clk).

Exemple (synthétisable)
Exemples utiles (testbench) :
\begin{verbatim}
wait on A, B; -- réagit aux changements de A ou B
wait until clk’event and clk=’1’; -- front montant
wait for 20 ns; -- délai de simulation
\end{verbatim}

5) Communication entre processus

Idée clé
Les signaux sont globaux à l’architecture : un process peut lire/écrire un signal produit par un
autre process. On câble donc les blocs au moyen de signaux communs.

2
 Exemple (synthétisable)
Additionneur 1-bit découpé en 3 process (simulation avec \texttt{after}) :
\begin{verbatim}
signal s1, s2, s3 : std_logic;
process(In1,In2) begin s1 <= (In1 xor In2) after 5 ns;
s3 <= (In1 and In2) after 5 ns; end process;
process(s1,C_in) begin Somme <= (s1 xor C_in) after 5 ns;
s2 <= (s1 and C_in) after 5 ns; end process;
process(s2,s3) begin C_out <= (s2 or s3) after 5 ns; end process;
\end{verbatim}

6) Attributs prédéfinis (tableaux/vecteurs)

Attribut Sens (exemple pour Data: std_logic_vector(7 downto 0))

’left, ’right Indices extrêmes : 7, 0
’high, ’low Indices max/min : 7, 0
’length Longueur : 8
’range, ’reverse_range 7 downto 0, 0 to 7

7) Mind maps (claires)

signaux
globaux

’length
comm.
’range

attributs

décodeurs

Procédural case

MUX

liste process

wait if

vars

latch ?
priorités

3
8) Mini-exercices (entraînement rapide)
1. Écrire un process synchrone (front montant) qui réalise un compteur modulo 10 avec reset
asynchrone actif bas.
2. Reprendre le MUX 4→1 en case et ajouter un signal EN (validation) : si EN=’0’, sortie à zéro.
3. Écrire un process avec wait until (testbench) qui génère une horloge 50 MHz pendant 1 ms.
4. Montrer, sur un exemple, l’utilité de ’length pour écrire un code générique sur la taille d’un bus.

9) À retenir (checklist)
Mémo
1. process = concurrent à l’extérieur, séquentiel à l’intérieur ; déclenchement par liste ou wait.
2. if (priorités) et case (sélection exclusive) : couvrir tous les cas pour éviter les latches.
3. wait on/until/for utile en testbench ; en synthèse, préférer rising_edge(clk).
4. Communication via signaux globaux ; attributs ’left/right/length/range.

4
 Chapitre IV — VHDL : Instructions concurrentes & logique
combinatoire
Résumé autonome : zone concurrente, <=, when/else, with/select, concaténation, délais, exemples

1) Concurrence vs séquentiel (bien comprendre)

Idée clé
Dans une architecture VHDL, tout ce qui est après begin (hors process) est concurrent :
toutes les instructions s’évaluent en parallèle. À l’intérieur d’un process, les instructions sont
séquentielles (ordre d’exécution).

— Zone concurrente : affectations simples, conditionnelles, sélectionnées, instanciations, process

(un process lui-même est concurrent par rapport aux autres).
— Zone séquentielle : if/elsif/else, case, for/while, affectations aux signaux (<=) et
variables (:=) dans un process.
— L’ordre d’écriture des affectations concurrentes n’a aucune importance (le matériel est
parallèle).

2) Les 3 instructions concurrentes essentielles

Mémo
1. Affectation simple S <= A and B; (porte logique, équations directes)
2. Affectation conditionnelle S <= V1 when C1 else V2 when C2 else ... VM; (prio-
rité implicite)
3. Affectation sélectionnée with Sel select S <= V1 when X1, ... , VM when
others; (pas de priorité)

1) Affectation simple <= (+ concaténation &).

Exemple (synthétisable)
Logique & concaténation :

S1 <= A and B; -- AND

S2 <= (A or B) and (not C); -- Combinaisons
S8 <= A3 & B3 & "01"; -- concaténer A(2:0), B(2:0) et 2 bits constants

2) Affectation conditionnelle when/else (avec priorité).

Exemple (synthétisable)
Détecteur de priorité 3 entrées (P2 > P1 > P0) :

Y <= "10" when P2=’1’ else -- priorité la plus forte

"01" when P1=’1’ else
"00" when P0=’1’ else
"00"; -- défaut

Idée : la première condition vraie gagne (priorité implicite).

3) Affectation sélectionnée with/select (sans priorité).

1
 Exemple (synthétisable)
MUX 8→1 (plus lisible qu’un long when/else) :

with Sel select

Y <= A when "000",
B when "001",
C when "010",
D when "011",
E when "100",
F when "101",
G when "110",
H when others; -- couvre "111" et tout cas non listé

3) Délais after : utile en simulation, ignoré en synthèse

Attention
after 2 ns n’a aucun effet en synthèse : l’outil l’ignore. Les délais réels dépendront de la
techno, du placement/routage, etc. Utilisez after pour simuler un temps de propagation.

-- Simulation uniquement (pas d’effet matériel en synthèse)

I1 <= A and B after 2 ns;

4) Exemples combinatoires (prêts à adapter)

4.1 MUX 4→1 (style conditionnel).

Y <= A when Sel="00" else

B when Sel="01" else
C when Sel="10" else
D; -- Sel="11" (défaut)

4.2 Addition/Soustraction 8 bits selon SEL.

with SEL select

S <= std_logic_vector(unsigned(A)+unsigned(B)) when ’1’,
std_logic_vector(unsigned(A)-unsigned(B)) when others;

4.3 Transcodeur Gray(3) → Binaire(3) (idée).

with G select
B <= "000" when "000",
"001" when "001",
"011" when "011",
"010" when "010",
"110" when "110",
"111" when "111",
"101" when "101",
"100" when others;

2
4.4 Décodeur 7 segments (0–9) en when/else (schéma de principe).

SEG <= "1111110" when DEC="0000" else -- 0

"0110000" when DEC="0001" else -- 1
-- ...
"1111011" when DEC="1001" else -- 9
"0000000"; -- défaut (éteint)

5) Mind maps (claires)

Instanciation others

process with/select

Autres Sélectionnée

Zone
concurrente

Affect.
Conditionnelle
simple

<= Priorité

Concat & when/else

3
 Simulation Concat

Ignoré en
synthèse Équations

after simple <=

Choisir

when/else with/select others

Priorités

Tables
Détecteurs
MUX

6) Mini-exercices (pour s’entraîner)

1. Écrire le code d’un décodeur 1 parmi 4 en zone concurrente : version when/else puis
with/select.
2. Encoder 1 parmi 4 → 2 bits : table de vérité puis when/else.
3. 7 segments : compléter la table 0–9 et écrire la version with/select.

7) À retenir (checklist)
Mémo
1. Zone concurrente : tout est évalué en parallèle ; l’ordre des lignes n’a pas d’importance.
2. when/else = priorité (première condition vraie gagne) ; with/select = sans priorité
(others obligatoire).
3. after : simulation uniquement ; ignoré en synthèse.
4. Concaténation & pour assembler des bits/vecteurs.

4
 Chapitre VI — VHDL : Description structurelle
Résumé autonome : modélisation structurelle, instanciation, hiérarchie, génériques, fonctions/procédures, exos

1) Modélisation structurelle : composer des blocs

Idée clé
La description structurelle assemble des composants (sous-ensembles testés) pour décrire
une architecture hiérarchique. Idéal pour les conceptions modulaires, la réutilisation et
l’optimisation.

— Styles VHDL : comportemental (process), flot de données, structurel, hybride.

— Un composant peut être instancié plusieurs fois ; chaque instance a un label (nom) et ses
connexions (signaux).
— Chaque entité/architecture est en général dans un fichier .vhd séparé (réutilisable).

2) Déclaration de composant & instanciation

Mémo
Étapes : (1) déclarer le component (prototype ports), (2) déclarer les signaux d’interconnexion,
(3) instancier avec port map (et generic map si besoin).

Exemple (synthétisable)
Déclaration puis instanciation (porte AND à 2 entrées) :
\begin{verbatim}
-- Déclaration
component AND2 is
port(a,b : in std_logic; s : out std_logic);
end component;

-- Signaux d’interconnexion
signal z : std_logic;

-- Instanciation (label + port map)

U0: AND2 port map (a=>e1, b=>e2, s=>z);
U1: AND2 port map (a=>z, b=>e3, s=>s_out);
\end{verbatim}

3) Hiérarchie et configuration
Idée clé
On peut composer des niveaux hiérarchiques (TOP → sous-blocs → sous-sous-blocs. . .). Une
unité de configuration peut choisir quelle architecture d’un composant utiliser.

Exemple (synthétisable)
Schéma dadditionneur (structurel) : instancier des demi-additionneurs
(\textit{half-adder}) puis les relier (XOR/AND).
\begin{verbatim}
-- (esquisse) Additionneur 1 bit à partir de demi-adders
component HA is port(a,b:in std_logic; s,c:out std_logic); end component;
signal s0,c0,c1 : std_logic;
H0: HA port map (a=>A, b=>B, s=>s0, c=>c0);

1
 H1: HA port map (a=>s0,b=>Cin,s=>S , c=>c1);
COUT <= c0 or c1;
\end{verbatim}

4) Généricité : rendre les blocs paramétrables

Mémo
Un generic rend un composant paramétrable (taille des bus, délais de simulation, etc.).

Exemple (synthétisable)
Additionneur N bits paramétrable :
\begin{verbatim}
component ADD_N is
generic (N : positive := 8);
port (A,B : in std_logic_vector(N-1 downto 0);
S : out std_logic_vector(N-1 downto 0));
end component;

-- Instanciation pour 12 bits :

U_ADD: ADD_N generic map (N=>12)
port map (A=>OP1, B=>OP2, S=>S);
\end{verbatim}

5) Sous-programmes : fonctions & procédures

Aspect Fonction Aspect Procédure

Paramètres Entrées (non modifiées) Paramètres Entrées/Sorties possibles
Retour Une valeur (utilisable dans une Retour Aucune (effet via paramètres
expression) out/inout)
Appel Dans une expression Appel Comme une instruction

Exemple (synthétisable)
Procédure \texttt{MinMax} (deux sorties) et fonction \texttt{FMin} :
\begin{verbatim}
procedure MinMax(a,b : in unsigned(7 downto 0);
Min,Max : out unsigned(7 downto 0)) is
begin
if a<b then Min<=a; Max<=b; else Min<=b; Max<=a; end if;
end procedure;

function FMin(a,b : unsigned(7 downto 0)) return unsigned is

variable m: unsigned(7 downto 0);
begin
if a<b then m:=a; else m:=b; end if; return m;
end function;
\end{verbatim}

2
6) Mind maps (claires)

fonctions
procédures

paramètres
Sous-prog.
N bits

Génériques

Structurel

Hiérarchie

réutiliser
Composants
TOP →
sous-blocs

déclarer
instancier

7) Mini-exercices (entraînement rapide)

1. Déclarer un composant XOR2 puis construire un comparateur d’égalité (A==B) en l’assemblant
avec un inverseur.
2. Écrire une entité REG_N générique (N bits) avec clk et rst_n, puis instancier deux versions (8
et 16 bits).
3. Créer un additionneur structurel N bits à partir de demi-adders (hiérarchie).
4. Écrire une fonction FMax et une procédure Clamp(min,max) pour saturer une valeur unsigned.

8) À retenir (checklist)
Mémo
1. Le style structurel assemble des composants instanciés et câblés par des signaux.
2. Les génériques rendent les blocs paramétrables (taille, délais. . .).
3. Fonctions (valeur de retour) vs procédures (paramètres out/inout).
4. Chaque bloc dans son .vhd ⇒ hiérarchie propre, réutilisation facilitée.