Systèmes Numériques (SIN) - Semestre 1

PART A - Présentation Générale du Cours

Contexte de la formation

Les systèmes numériques sont au cœur de tous les équipements électroniques modernes : ordinateurs, smartphones, systèmes embarqués, automatismes industriels. Ce module introduit les fondements de la logique digitale et de la conception de circuits numériques, compétences indispensables pour tout technicien ou ingénieur en GEII. La maîtrise du VHDL (langage de description matériel) permet de concevoir des systèmes numériques complexes sur FPGA.

Positionnement dans le cursus

Public visé

Étudiants de première année DUT GEII découvrant la conception de circuits numériques depuis les bases (portes logiques) jusqu’à la programmation FPGA en VHDL.

PART B: EXPÉRIENCE, CONTEXTE ET FONCTION

Objectifs pédagogiques

Compétences en logique numérique :

Compétences en VHDL et FPGA :

Compétences transversales :

Programme détaillé

1. Systèmes de numération (8h)

Bases numériques :

Binaire (base 2) :

Octal (base 8) :

Hexadécimal (base 16) :

Conversions entre bases :

Décimal → Binaire (divisions successives) :

45₁₀ → Binaire ?
45 / 2 = 22 reste 1  (bit de poids faible)
22 / 2 = 11 reste 0
11 / 2 = 5 reste 1
5 / 2 = 2 reste 1
2 / 2 = 1 reste 0
1 / 2 = 0 reste 1  (bit de poids fort)
Résultat : 101101₂

Binaire → Hexadécimal (groupes de 4 bits) :

11010110₂ = 1101 0110 = D6₁₆

Codes numériques :

BCD (Binary Coded Decimal) :

Code Gray :

Décimal Binaire Gray
0 000 000
1 001 001
2 010 011
3 011 010
4 100 110

Code ASCII :

Arithmétique binaire :

Addition binaire :

  1011  (11)
+ 0110  (6)
-------
 10001  (17)

Règles : 0+0=0, 0+1=1, 1+1=10 (retenue)

Soustraction binaire (complément à 2) :

A - B = A + (-B)
-B = complément à 1 de B + 1

Exemple : 7 - 3
7 = 0111
3 = 0011 → Complément à 1 : 1100 → +1 : 1101 (-3)
0111 + 1101 = 10100 → on garde les 4 bits de poids faible : 0100 = 4 ✓

Représentation des nombres signés :

Sur n bits, plage : -2^(n-1) à 2^(n-1)-1 Exemple sur 8 bits : -128 à +127

2. Algèbre de Boole et logique combinatoire (15h)

Portes logiques fondamentales :

Porte Symbole Équation Table de vérité (A, B → S)
NOT (inverseur) ¬A ou A’ S = NOT A 0→1, 1→0
AND (ET) A ∧ B S = A AND B 00→0, 01→0, 10→0, 11→1
OR (OU) A ∨ B S = A OR B 00→0, 01→1, 10→1, 11→1
NAND (NON-ET) A ↑ B S = NOT (A AND B) 00→1, 01→1, 10→1, 11→0
NOR (NON-OU) A ↓ B S = NOT (A OR B) 00→1, 01→0, 10→0, 11→0
XOR (OU exclusif) A ⊕ B S = A XOR B 00→0, 01→1, 10→1, 11→0
XNOR A ⊙ B S = NOT (A XOR B) 00→1, 01→0, 10→0, 11→1

Propriétés de l’algèbre de Boole :

Fonctions logiques et tables de vérité :

Exemple : Fonction S = (A AND B) OR (NOT C)

A B C NOT C A AND B S
0 0 0 1 0 1
0 0 1 0 0 0
0 1 0 1 0 1
0 1 1 0 0 0
1 0 0 1 0 1
1 0 1 0 0 0
1 1 0 1 1 1
1 1 1 0 1 1

Formes canoniques :

Simplification par tableaux de Karnaugh :

Tableau de Karnaugh pour 3 variables (A, B, C) :

      C'  C
   ┌────┬────┐
AB' │ 0  │ 1  │
   ├────┼────┤
A'B'│ 2  │ 3  │
   ├────┼────┤
A'B │ 6  │ 7  │
   ├────┼────┤
AB  │ 4  │ 5  │
   └────┴────┘

Méthode :

  1. Remplir le tableau avec les valeurs de sortie
  2. Regrouper les ‘1’ adjacents par puissances de 2 (1, 2, 4, 8…)
  3. Extraire les termes simplifiés

Circuits combinatoires usuels :

Demi-additionneur (Half Adder) :

Additionneur complet (Full Adder) :

Multiplexeur (MUX) :

Démultiplexeur (DEMUX) :

Décodeur :

Encodeur :

Comparateur :

3. Logique séquentielle (12h)

Différence combinatoire/séquentiel :

Bascules (Flip-Flops) :

Bascule RS (Reset-Set) :

Bascule D (Data) :

Bascule JK :

Bascule T (Toggle) :

Registres :

Compteurs :

Compteur asynchrone :

Compteur synchrone :

Machines à états finis (FSM) :

Types :

Diagramme d’états :

     ┌──────┐  E=1  ┌──────┐
     │  S0  │──────→│  S1  │
     └──────┘       └──────┘
        ↑              │
        └──────────────┘
           E=0

Étapes de conception :

  1. Diagramme d’états
  2. Table de transition
  3. Codage des états (binaire)
  4. Équations des bascules et sorties
  5. Implémentation (schéma ou VHDL)

4. Introduction au VHDL (20h)

VHDL = VHSIC Hardware Description Language

Structure d’un code VHDL :

-- Bibliothèques
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

-- Entité (interface externe)
entity PorteAND is
    Port (
        A : in STD_LOGIC;
        B : in STD_LOGIC;
        S : out STD_LOGIC
    );
end PorteAND;

-- Architecture (comportement interne)
architecture Behavioral of PorteAND is
begin
    S <= A AND B;
end Behavioral;

Types de données :

Opérateurs :

Affectations :

Processus (PROCESS) :

process(clk, reset)  -- Liste de sensibilité
begin
    if reset = '1' then
        compteur <= 0;
    elsif rising_edge(clk) then  -- Front montant d'horloge
        compteur <= compteur + 1;
    end if;
end process;

Structures de contrôle :

IF-THEN-ELSE :

if (condition) then
    -- instructions
elsif (autre_condition) then
    -- instructions
else
    -- instructions
end if;

CASE :

case sel is
    when "00" => sortie <= entree0;
    when "01" => sortie <= entree1;
    when "10" => sortie <= entree2;
    when others => sortie <= entree3;
end case;

FOR LOOP :

for i in 0 to 7 loop
    sortie(i) <= entree(7-i);  -- Inversion de bus
end loop;

Exemple complet : Compteur 8 bits

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity Compteur8bits is
    Port (
        clk : in STD_LOGIC;
        reset : in STD_LOGIC;
        enable : in STD_LOGIC;
        count : out STD_LOGIC_VECTOR(7 downto 0)
    );
end Compteur8bits;

architecture Behavioral of Compteur8bits is
    signal compteur : unsigned(7 downto 0) := (others => '0');
begin
    process(clk, reset)
    begin
        if reset = '1' then
            compteur <= (others => '0');
        elsif rising_edge(clk) then
            if enable = '1' then
                compteur <= compteur + 1;
            end if;
        end if;
    end process;
    
    count <= std_logic_vector(compteur);
end Behavioral;

Travaux pratiques

TP1 : Prise en main de Quartus Prime

TP2 : Circuits combinatoires

TP3 : Introduction VHDL

TP4 : Logique séquentielle

TP5 : Machine à états finis

PART C: ASPECTS TECHNIQUES

Outils de conception

Intel Quartus Prime

Installation :

Workflow de conception :

  1. Création projet : File → New Project Wizard
  2. Ajout fichiers : .vhd, .v, ou schéma
  3. Compilation : Processing → Start Compilation (Ctrl+L)
  4. Analyse : Compilation Report (ressources, timing, etc.)
  5. Assignement pins : Assignments → Pin Planner
  6. Programmation : Tools → Programmer

Analyses disponibles :

ModelSim (Simulation)

Fonctionnalités :

Exemple de testbench :

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity Compteur_TB is
end Compteur_TB;

architecture Behavioral of Compteur_TB is
    component Compteur8bits
        Port (clk, reset, enable : in STD_LOGIC;
              count : out STD_LOGIC_VECTOR(7 downto 0));
    end component;
    
    signal clk_tb, reset_tb, enable_tb : STD_LOGIC := '0';
    signal count_tb : STD_LOGIC_VECTOR(7 downto 0);
    constant clk_period : time := 10 ns;
    
begin
    UUT: Compteur8bits port map(clk_tb, reset_tb, enable_tb, count_tb);
    
    -- Génération horloge
    clk_process : process
    begin
        clk_tb <= '0';
        wait for clk_period/2;
        clk_tb <= '1';
        wait for clk_period/2;
    end process;
    
    -- Stimulus
    stim_proc: process
    begin
        reset_tb <= '1';
        wait for 20 ns;
        reset_tb <= '0';
        enable_tb <= '1';
        wait for 1000 ns;
        enable_tb <= '0';
        wait;
    end process;
end Behavioral;

Cartes FPGA utilisées

Altera/Intel Cyclone IV/V

Caractéristiques :

Cartes de développement :

Périphériques typiques :

Méthodologie de conception

Bonnes pratiques VHDL

Nommage :

Commentaires :

-- Commentaire ligne simple

--======================
-- Bloc de commentaire
--======================

Conception synchrone : ✅ Toujours utiliser une horloge unique si possible ✅ Éviter les logiques asynchrones complexes ✅ Réinitialiser les signaux (reset)

Testabilité :

Débogage

Erreurs de compilation courantes : ❌ Signal not declared → Oublié de déclarer le signal ❌ Multiple drivers → Signal assigné à plusieurs endroits ❌ Type mismatch → Conversion de type nécessaire (std_logic_vector ↔ unsigned)

Outils de débogage :

PART D: ANALYSE ET RÉFLEXION

Évaluation des compétences

Modalités d’évaluation

Contrôle continu (40%) :

Travaux pratiques (35%) :

Projet (15%) :

Examen terminal (10%) :

Grille d’évaluation TP

Critère Points
Fonctionnalité : Circuit fonctionne sur FPGA /6
Code VHDL : Qualité, clarté, commentaires /5
Simulation : Testbench et chronogrammes /4
Tests : Validation complète /3
Rapport : Clarté, schémas, analyses /2
Total /20

Compétences acquises

Savoirs théoriques

✓ Maîtriser l’algèbre de Boole et les systèmes de numération ✓ Comprendre la logique combinatoire et séquentielle ✓ Connaître les circuits numériques fondamentaux ✓ Comprendre les principes des FPGA

Savoir-faire techniques

✓ Concevoir des circuits numériques (combinatoires et séquentiels) ✓ Simplifier des fonctions logiques (Karnaugh) ✓ Programmer en VHDL ✓ Simuler et valider des designs numériques ✓ Synthétiser et programmer des FPGA avec Quartus ✓ Déboguer des circuits numériques

Savoir-être

✓ Rigueur dans la conception (chronogrammes, timing) ✓ Méthodologie de test et validation ✓ Documentation technique claire ✓ Travail en équipe sur projets

Progression et liens avec le cursus

Suite du parcours Systèmes Numériques

Semestre Module Contenu
S1 SIN 1 Logique combinatoire, séquentielle, VHDL de base
S2 Logique Séquentielle FSM avancées, FIFO, mémoires, bus
S3 Architectures Numériques Avancées Processeurs, pipelines, VHDL avancé
S4 Projet FPGA Conception système complet (SoC)

Liens avec les autres matières

Matière Utilisation des systèmes numériques
Programmation Similarités algorithmes/FSM
Informatique Embarquée Microcontrôleurs (logique interne)
Électronique Interface analogique/numérique (ADC, DAC)
Automatique Contrôleurs numériques, régulateurs discrets
Télécommunications Modulation/démodulation numérique

Indicateurs de réussite

Statistiques

Taux de réussite : 88% Moyenne générale : 12.8/20

Difficultés fréquentes : ❌ Confusion entre logique combinatoire et séquentielle ❌ Oubli de la liste de sensibilité dans les process ❌ Conversions de types en VHDL ❌ Timing (setup/hold violations) ❌ Simplification par Karnaugh (regroupements)

Clés de réussite : ✅ Dessiner les chronogrammes avant de coder ✅ Toujours simuler avant de synthétiser ✅ Commencer simple, complexifier progressivement ✅ Utiliser les exemples de code fournis ✅ Tester sur carte FPGA régulièrement

Débouchés et applications

Applications professionnelles

Métiers utilisant les FPGA/VHDL :

Industries :

📚 Ressources complémentaires

Ouvrages de référence

Logique numérique :

  1. Systèmes logiques - Tome 1 et 2 - A. Vachoux (PPUR) - Référence francophone
  2. Digital Design - M. Morris Mano (Pearson) - Classique mondial
  3. Circuits numériques et synthèse logique - Jacques Weber (Eyrolles)

VHDL :

Sites web et tutoriels

Cours en ligne :

Forums et communautés :

Simulateurs en ligne :

Logiciels libres alternatifs

GHDL : Simulateur VHDL open source GTKWave : Visualisateur de formes d’ondes Icarus Verilog : Si vous voulez apprendre Verilog aussi

🎯 Conseils méthodologiques

Pour réussir en systèmes numériques

Pendant les cours/TD :

En TP :

Travail personnel (2-3h/semaine) :

Erreurs à éviter

❌ Oublier rising_edge(clk) dans les process synchrones ❌ Mélanger affectations <= et := ❌ Négliger les types (STD_LOGIC vs INTEGER vs UNSIGNED) ❌ Créer des boucles combinatoires (A dépend de A) ❌ Ne pas tester les cas limites (reset, overflow, etc.)

✅ Toujours déclarer un signal de reset ✅ Utiliser des noms de signaux explicites ✅ Commenter son code VHDL ✅ Vérifier le Resource Usage après compilation ✅ Documenter ses montages avec schémas

Bon courage dans la découverte passionnante des systèmes numériques ! ⚡🔢

“In theory, theory and practice are the same. In practice, they are not.” - Yogi Berra

En systèmes numériques, la simulation et les tests sur matériel réel sont essentiels. N’hésitez pas à expérimenter sur les cartes FPGA !

📖 Ressources complémentaires