Systemes Numeriques

Numeration - Logique Combinatoire - Logique Sequentielle

S01 : Traitement Numerique de l'Information

🔢 Numeration ⚡ Combinatoire 🔄 Sequentielle
🔢

Chapitre 1 : Systemes de Numeration

Binaire, Octal, Decimal, Hexadecimal

🎯 Objectifs du chapitre

  • Comprendre les differentes bases de numeration
  • Representer les nombres dans chaque base
  • Connaitre les prefixes et notations
  • Compter dans les differentes bases

1.1 Definition d'un Systeme de Numeration

📖
Systeme de numeration positionnel Systeme ou la valeur d'un chiffre depend de sa position dans le nombre. La base B definit le nombre de symboles utilises (0 a B-1). Chaque position represente une puissance de la base.
Valeur d'un nombre en base B N = an×Bn + an-1×Bn-1 + ... + a1×B1 + a0×B0

1.2 Les Quatre Bases Principales

BaseNomSymbolesPrefixe CUsage
2Binaire0, 10bCircuits numeriques
8Octal0-70Unix (permissions)
10Decimal0-9aucunUsage courant
16Hexadecimal0-9, A-F0xAdresses memoire

Correspondance Hexadecimal

Hex0123456789ABCDEF
Dec0123456789101112131415
Bin0000000100100011010001010110011110001001101010111100110111101111

1.3 Comptage en Binaire

    COMPTAGE BINAIRE SUR 4 BITS
    
    Decimal │ Binaire │ Hex     Decimal │ Binaire │ Hex
    ────────┼─────────┼─────    ────────┼─────────┼─────
       0    │  0000   │  0         8    │  1000   │  8
       1    │  0001   │  1         9    │  1001   │  9
       2    │  0010   │  2        10    │  1010   │  A
       3    │  0011   │  3        11    │  1011   │  B
       4    │  0100   │  4        12    │  1100   │  C
       5    │  0101   │  5        13    │  1101   │  D
       6    │  0110   │  6        14    │  1110   │  E
       7    │  0111   │  7        15    │  1111   │  F
    
    Avec n bits, on peut representer 2ⁿ valeurs (de 0 a 2ⁿ-1)
    4 bits → 16 valeurs (0 a 15)
    8 bits → 256 valeurs (0 a 255)

1.4 Poids des Bits

    POIDS DES BITS (exemple: 10110101₂ = 181₁₀)
    
    Position:    7    6    5    4    3    2    1    0
    Bit:         1    0    1    1    0    1    0    1
    Poids:      128   64   32   16   8    4    2    1
                 │         │    │         │         │
                 └─────────┼────┼─────────┼─────────┤
                           │    │         │         │
    Valeur:     128 + 0 + 32 + 16 + 0 +  4  + 0 +  1  = 181
    
    
    MSB = Most Significant Bit (bit de poids fort) = position 7
    LSB = Least Significant Bit (bit de poids faible) = position 0
💡
Puissances de 2 a connaitre 2⁰=1, 2¹=2, 2²=4, 2³=8, 2⁴=16, 2⁵=32, 2⁶=64, 2⁷=128, 2⁸=256, 2⁹=512, 2¹⁰=1024
🔄

Chapitre 2 : Conversions entre Bases

Methodes de conversion

2.1 Decimal → Binaire (Divisions successives)

    METHODE DES DIVISIONS PAR 2
    
    Exemple : Convertir 45₁₀ en binaire
    
    45 ÷ 2 = 22  reste  1  ←─┐
    22 ÷ 2 = 11  reste  0     │
    11 ÷ 2 = 5   reste  1     │  Lire les restes
     5 ÷ 2 = 2   reste  1     │  de bas en haut
     2 ÷ 2 = 1   reste  0     │
     1 ÷ 2 = 0   reste  1  ←─┘
    
    Resultat : 45₁₀ = 101101₂
    
    Verification : 32 + 8 + 4 + 1 = 45 ✓

2.2 Binaire → Decimal (Addition des poids)

    METHODE DES POIDS
    
    Exemple : Convertir 11010110₂ en decimal
    
    Position:  7   6   5   4   3   2   1   0
    Bit:       1   1   0   1   0   1   1   0
    Poids:    128  64  32  16   8   4   2   1
    
    Calcul : 128 + 64 + 0 + 16 + 0 + 4 + 2 + 0
           = 128 + 64 + 16 + 4 + 2
           = 214
    
    Resultat : 11010110₂ = 214₁₀

2.3 Binaire ↔ Hexadecimal (Groupes de 4 bits)

    BINAIRE → HEXADECIMAL
    
    Grouper par 4 bits depuis la droite, puis convertir chaque groupe
    
    Exemple : 10111010₂ → Hex
    
    1011  1010
      ↓     ↓
      B     A
    
    Resultat : 10111010₂ = BA₁₆ = 0xBA
    
    
    HEXADECIMAL → BINAIRE
    
    Remplacer chaque chiffre hex par ses 4 bits
    
    Exemple : 3F₁₆ → Binaire
    
      3      F
      ↓      ↓
    0011   1111
    
    Resultat : 3F₁₆ = 00111111₂
💡
Astuce Pour convertir Binaire ↔ Octal, utiliser des groupes de 3 bits au lieu de 4.

2.4 Tableau Recapitulatif des Conversions

DecimalBinaireOctalHexadecimal
00000 000000000
100000 10100120A
250001 100103119
1000110 010014464
1270111 11111777F
2551111 1111377FF
📝

Chapitre 3 : Codes Binaires Speciaux

Nombres signes, reels, caracteres

3.1 Nombres Signes : Complement a 2

📖
Complement a 2 (Two's Complement) Methode standard pour representer les nombres signes. Le bit de poids fort (MSB) indique le signe : 0 = positif, 1 = negatif. Sur n bits : plage de -2n-1 a +2n-1-1.

Calcul du Complement a 2

    METHODE : Inverser tous les bits + ajouter 1
    
    Exemple : Representer -45 sur 8 bits
    
    1. Ecrire +45 en binaire : 00101101
    
    2. Inverser tous les bits : 11010010  (complement a 1)
    
    3. Ajouter 1 :             11010010
                             +        1
                             ──────────
                               11010011  (complement a 2)
    
    Resultat : -45₁₀ = 11010011₂ (en complement a 2)
    
    
    PLAGE SUR 8 BITS :
    
    01111111 = +127 (maximum positif)
    00000001 = +1
    00000000 = 0
    11111111 = -1
    10000000 = -128 (minimum negatif)
BitsNon signeSigne (C2)
80 a 255-128 a +127
160 a 65 535-32 768 a +32 767
320 a 4 294 967 295-2 147 483 648 a +2 147 483 647

3.2 Nombres Reels : Virgule Flottante (IEEE 754)

    FORMAT IEEE 754 SIMPLE PRECISION (32 bits)
    
    ┌───┬─────────────────┬─────────────────────────────────────┐
    │ S │    Exposant     │             Mantisse                │
    │ 1 │     8 bits      │             23 bits                 │
    └───┴─────────────────┴─────────────────────────────────────┘
     31   30          23   22                                  0
    
    S = Signe (0 = positif, 1 = negatif)
    Exposant = Exposant biaise (biais = 127)
    Mantisse = Partie fractionnaire (1.xxxxx implicite)
    
    Valeur = (-1)^S × 1.Mantisse × 2^(Exposant - 127)
    
    
    Exemple : 5.75₁₀
    
    5.75 = 101.11₂ = 1.0111 × 2²
    
    S = 0 (positif)
    Exposant = 2 + 127 = 129 = 10000001₂
    Mantisse = 01110000000000000000000
    
    Resultat : 0 10000001 01110000000000000000000

3.3 Codes Caracteres : ASCII et Unicode

CaractereASCII (Dec)ASCII (Hex)Binaire
'0'480x300011 0000
'9'570x390011 1001
'A'650x410100 0001
'Z'900x5A0101 1010
'a'970x610110 0001
'z'1220x7A0111 1010
Espace320x200010 0000
💡
Astuces ASCII
  • Majuscule → Minuscule : ajouter 32 (ou mettre bit 5 a 1)
  • Chiffre '0'-'9' : soustraire 48 pour obtenir la valeur

3.4 Code BCD (Binary Coded Decimal)

    CODE BCD : Chaque chiffre decimal code sur 4 bits
    
    Exemple : 259₁₀ en BCD
    
    2        5        9
    ↓        ↓        ↓
    0010     0101     1001
    
    BCD : 0010 0101 1001
    
    
    DIFFERENCE BCD vs BINAIRE :
    
    Nombre   │  BCD            │  Binaire
    ─────────┼─────────────────┼──────────────
    25       │  0010 0101      │  0001 1001
    99       │  1001 1001      │  0110 0011
    
    BCD : Utile pour afficheurs 7 segments
🔣

Chapitre 4 : Algebre de Boole

Operateurs et theoremes fondamentaux

4.1 Operateurs Logiques de Base

⊙

ET (AND)

S = A · B
S = 1 si A=1 ET B=1

⊕

OU (OR)

S = A + B
S = 1 si A=1 OU B=1

⊘

NON (NOT)

S = Ā
S = inverse de A

Tables de Verite

ET (AND)
ABA·B
000
010
100
111
OU (OR)
ABA+B
000
011
101
111
XOR
ABA⊕B
000
011
101
110

4.2 Operateurs Complementaires

NAND (NON-ET)
ABA↑B
001
011
101
110
NOR (NON-OU)
ABA↓B
001
010
100
110
⚡
NAND et NOR sont universelles Toute fonction logique peut etre realisee uniquement avec des portes NAND ou uniquement avec des portes NOR.

4.3 Theoremes de l'Algebre de Boole

ProprieteForme ETForme OU
IdentiteA · 1 = AA + 0 = A
Element nulA · 0 = 0A + 1 = 1
IdempotenceA · A = AA + A = A
ComplementationA · Ā = 0A + Ā = 1
InvolutionA̿ = A
CommutativiteA · B = B · AA + B = B + A
Associativite(A·B)·C = A·(B·C)(A+B)+C = A+(B+C)
DistributiviteA·(B+C) = A·B + A·CA+(B·C) = (A+B)·(A+C)
AbsorptionA·(A+B) = AA + A·B = A

4.4 Theoremes de De Morgan

Theoremes de De Morgan A̅·̅B̅ = Ā + B̄ (Le complement d'un ET = OU des complements) A̅+̅B̅ = Ā · B̄ (Le complement d'un OU = ET des complements) 
    APPLICATION DE DE MORGAN
    
    Pour simplifier : F = (A·B)̄ + C̄
    
    Etape 1 : Appliquer De Morgan sur (A·B)̄
              (A·B)̄ = Ā + B̄
    
    Donc : F = Ā + B̄ + C̄
    
    
    Pour transformer en NAND uniquement :
    
    F = A·B + C
    
    En NAND :
    F = ((A·B)̄ · C̄)̄
    
    Schema : NAND(NAND(A,B), NAND(C,C))
📊

Chapitre 5 : Tableaux de Karnaugh

Simplification graphique des fonctions logiques

5.1 Principe du Tableau de Karnaugh

📖
Tableau de Karnaugh Methode graphique pour simplifier les fonctions logiques. Les cases adjacentes ne different que d'une seule variable (code Gray). On regroupe les 1 adjacents par puissances de 2 (1, 2, 4, 8...).

Construction pour 2, 3 et 4 variables

    KARNAUGH 2 VARIABLES      KARNAUGH 3 VARIABLES
    
         B                         BC
       0   1                   00  01  11  10
    ┌─────┬─────┐           ┌─────┬─────┬─────┬─────┐
  0 │     │     │         0 │     │     │     │     │
A   ├─────┼─────┤        A  ├─────┼─────┼─────┼─────┤
  1 │     │     │         1 │     │     │     │     │
    └─────┴─────┘           └─────┴─────┴─────┴─────┘
    
    
    KARNAUGH 4 VARIABLES
    
              CD
           00   01   11   10
        ┌─────┬─────┬─────┬─────┐
     00 │     │     │     │     │
        ├─────┼─────┼─────┼─────┤
     01 │     │     │     │     │
  AB    ├─────┼─────┼─────┼─────┤
     11 │     │     │     │     │
        ├─────┼─────┼─────┼─────┤
     10 │     │     │     │     │
        └─────┴─────┴─────┴─────┘
    
    NOTE : Les lignes et colonnes utilisent le CODE GRAY
    (00, 01, 11, 10) pour que les cases adjacentes
    ne different que d'un bit !

5.2 Regles de Regroupement

  • Groupes de 2n : 1, 2, 4, 8, 16 cases
  • Adjacence : Horizontale, verticale, ou par "repliement" (bords)
  • Recouvrement : Une case peut appartenir a plusieurs groupes
  • Maximiser : Faire les plus grands groupes possibles
  • Minimiser : Utiliser le moins de groupes possible
⚠️
Attention aux bords ! Le tableau se "replie" : la colonne de gauche est adjacente a celle de droite, la ligne du haut a celle du bas. Les 4 coins peuvent former un groupe !

5.3 Exemple Complet

    SIMPLIFICATION PAR KARNAUGH
    
    Table de verite :
    A B C │ S
    ──────┼───
    0 0 0 │ 1
    0 0 1 │ 0
    0 1 0 │ 1
    0 1 1 │ 1
    1 0 0 │ 1
    1 0 1 │ 0
    1 1 0 │ 1
    1 1 1 │ 1
    
    Tableau de Karnaugh :
    
              BC
           00   01   11   10
        ┌─────┬─────┬─────┬─────┐
      0 │  1  │  0  │  1  │  1  │
    A   ├─────┼─────┼─────┼─────┤
      1 │  1  │  0  │  1  │  1  │
        └─────┴─────┴─────┴─────┘
    
    Groupements :
    - Colonne 00 (4 cases) : /C (B et A elimes car ils varient)
    - Rectangle 11 et 10 (4 cases) : B
    
    Resultat : S = C̄ + B
    
    Verification : Sans simplification S aurait 6 termes !

5.4 Karnaugh 4 Variables - Exemple

    EXEMPLE 4 VARIABLES : F(A,B,C,D) = Σm(0,2,5,7,8,10,13,15)
    
              CD
           00   01   11   10
        ┌─────┬─────┬─────┬─────┐
     00 │  1  │  0  │  0  │  1  │   Groupe Rouge : coins
        ├─────┼─────┼─────┼─────┤   (cases 0,2,8,10) → B̄D̄
     01 │  0  │  1  │  1  │  0  │
  AB    ├─────┼─────┼─────┼─────┤   Groupe Vert : colonne 01,11
     11 │  0  │  1  │  1  │  0  │   (cases 5,7,13,15) → BD
        ├─────┼─────┼─────┼─────┤
     10 │  1  │  0  │  0  │  1  │
        └─────┴─────┴─────┴─────┘
    
    F = B̄D̄ + BD = B ⊕ D̄ (ou B XNOR D)
    
    Simplification de 8 termes a 2 termes !
⚙️

Chapitre 6 : Portes Logiques

Symboles et circuits integres

6.1 Symboles des Portes Logiques

    SYMBOLES IEC / ANSI DES PORTES LOGIQUES
    
    AND (ET)         OR (OU)          NOT (NON)
    
    A ──┬──┐         A ──┬──╲         A ────┬──o── S
    B ──┴──┼── S     B ──┴──╱── S           │
           │                                 └──
    
    NAND             NOR              XOR
    
    A ──┬──┐         A ──┬──╲         A ──┬──╲═╲
    B ──┴──┼─o─ S    B ──┴──╱─o─ S    B ──┴──╱═╱── S
           │
    
    
    REPRESENTATION SIMPLIFIEE (rectangles IEC)
    
    ┌─────┐    ┌─────┐    ┌─────┐    ┌─────┐
    │  &  │    │ ≥1  │    │  1  │    │ =1  │
    └─────┘    └─────┘    └─────┘    └─────┘
      AND        OR        NOT/XOR     XOR
    
    Avec cercle en sortie = fonction inversee (NAND, NOR)

6.2 Circuits Integres TTL/CMOS

ReferenceFonctionPortesEntrees
74LS00NAND42
74LS02NOR42
74LS04NOT61
74LS08AND42
74LS32OR42
74LS86XOR42
74LS10NAND33
74LS20NAND24
💡
Familles logiques
  • 74xx : TTL standard (5V)
  • 74LSxx : TTL Low-Power Schottky
  • 74HCxx : CMOS haute vitesse
  • 74HCTxx : CMOS compatible TTL
🔧

Chapitre 7 : Circuits Combinatoires

Decodeurs, multiplexeurs, additionneurs

7.1 Decodeur (Decoder)

📖
Decodeur n vers 2n Circuit avec n entrees et 2n sorties. Une seule sortie est active a la fois selon la combinaison binaire des entrees. 
    DECODEUR 2 VERS 4 (74LS139)
    
         A B │ Y0  Y1  Y2  Y3         ┌──────────────┐
        ─────┼────────────────    A ──┤              ├── Y0
         0 0 │  1   0   0   0     B ──┤   DECODEUR   ├── Y1
         0 1 │  0   1   0   0         │    2 → 4     ├── Y2
         1 0 │  0   0   1   0         │              ├── Y3
         1 1 │  0   0   0   1         └──────────────┘
    
    Equations :
    Y0 = Ā · B̄
    Y1 = Ā · B
    Y2 = A · B̄
    Y3 = A · B
    
    
    DECODEUR 3 VERS 8 (74LS138)
    
    Entrees : A, B, C (+ Enable G1, /G2A, /G2B)
    Sorties : Y0 a Y7 (actives a l'etat bas)
    
    Utilise pour le decodage d'adresses memoire

7.2 Encodeur (Encoder)

    ENCODEUR PRIORITAIRE 8 VERS 3 (74LS148)
    
    Fonction inverse du decodeur :
    - 8 entrees (I0 a I7)
    - 3 sorties binaires (A2, A1, A0)
    - Encode la position de l'entree active
    
    I7 I6 I5 I4 I3 I2 I1 I0 │ A2 A1 A0
    ────────────────────────┼──────────
     0  X  X  X  X  X  X  X │  1  1  1  (7)
     1  0  X  X  X  X  X  X │  1  1  0  (6)
     1  1  0  X  X  X  X  X │  1  0  1  (5)
     ...
    
    Priorite : I7 est la plus prioritaire

7.3 Multiplexeur (MUX)

📖
Multiplexeur 2n vers 1 Aiguillage de donnees : selectionne une entree parmi 2n et la transmet vers la sortie unique. Les n bits de selection determinent quelle entree est choisie. 
    MULTIPLEXEUR 4 VERS 1 (74LS153)
    
                               ┌───────────────┐
    D0 ────────────────────────┤               │
    D1 ────────────────────────┤    MUX        │
    D2 ────────────────────────┤   4 → 1      ├──── Y
    D3 ────────────────────────┤               │
                               ├───────────────┤
    S1 ────────────────────────┤   SEL         │
    S0 ────────────────────────┤               │
                               └───────────────┘
    
    Table de fonctionnement :
    S1 S0 │ Y
    ──────┼────
     0  0 │ D0
     0  1 │ D1
     1  0 │ D2
     1  1 │ D3
    
    Equation : Y = D0·S̄1·S̄0 + D1·S̄1·S0 + D2·S1·S̄0 + D3·S1·S0
    
    
    UTILISATION COMME GENERATEUR DE FONCTION
    
    Un MUX 4→1 peut implementer n'importe quelle fonction de 2 variables
    en connectant 0, 1, ou les entrees aux entrees donnees.

7.4 Demultiplexeur (DEMUX)

    DEMULTIPLEXEUR 1 VERS 4
    
    Fonction inverse du MUX :
    - 1 entree de donnees (D)
    - 2 entrees de selection (S1, S0)
    - 4 sorties (Y0, Y1, Y2, Y3)
    
    L'entree D est routee vers la sortie selectionnee
    
    S1 S0 │ Y0   Y1   Y2   Y3
    ──────┼──────────────────
     0  0 │  D    0    0    0
     0  1 │  0    D    0    0
     1  0 │  0    0    D    0
     1  1 │  0    0    0    D
    
    Note : Un decodeur avec Enable peut servir de DEMUX
    (l'Enable devient l'entree de donnees)

7.5 Additionneur

Demi-Additionneur (Half Adder)

    DEMI-ADDITIONNEUR
    
    Additionne 2 bits sans retenue entrante
    
     A  B │ S  Cout        S = A ⊕ B (XOR)
    ──────┼─────────       Cout = A · B (AND)
     0  0 │ 0   0
     0  1 │ 1   0          ┌─────────────┐
     1  0 │ 1   0      A ──┤  HALF       ├── S
     1  1 │ 0   1      B ──┤  ADDER      ├── Cout
                           └─────────────┘

Additionneur Complet (Full Adder)

    ADDITIONNEUR COMPLET
    
    Additionne 2 bits + retenue entrante
    
     A  B  Cin │ S  Cout
    ───────────┼─────────
     0  0   0  │ 0   0
     0  0   1  │ 1   0
     0  1   0  │ 1   0
     0  1   1  │ 0   1
     1  0   0  │ 1   0
     1  0   1  │ 0   1
     1  1   0  │ 0   1
     1  1   1  │ 1   1
    
    S = A ⊕ B ⊕ Cin
    Cout = A·B + Cin·(A ⊕ B)
    
    
    ADDITIONNEUR 4 BITS (74LS283)
    
         A3 B3   A2 B2   A1 B1   A0 B0
          │  │    │  │    │  │    │  │
         ┌┴──┴┐  ┌┴──┴┐  ┌┴──┴┐  ┌┴──┴┐
    C4 ──┤ FA ├──┤ FA ├──┤ FA ├──┤ FA ├── C0 (=0)
         └─┬──┘  └─┬──┘  └─┬──┘  └─┬──┘
           S3      S2      S1      S0
    
    Resultat : S = A + B (addition binaire)

7.6 Comparateur

    COMPARATEUR 4 BITS (74LS85)
    
                   ┌─────────────────┐
    A3-A0 ─────────┤                 ├── A > B
    B3-B0 ─────────┤   COMPARATEUR   ├── A = B
                   │                 ├── A < B
    Cascade in ────┤                 │
                   └─────────────────┘
    
    Comparaison bit a bit de A et B
    
    Equation pour 1 bit :
    - A > B : A · B̄
    - A = B : A ⊙ B (XNOR)
    - A < B : Ā · B
    
    Pour n bits : chainage en cascade possible
🔄

Chapitre 8 : Bascules (Flip-Flops)

RS, D, JK - Logique sequentielle

🎯 Objectifs du chapitre

  • Distinguer logique combinatoire et sequentielle
  • Comprendre le fonctionnement des bascules
  • Maitriser les tables caracteristiques
  • Dessiner des chronogrammes

8.1 Combinatoire vs Sequentielle

⚡

Combinatoire

Sortie = f(entrees actuelles)
Pas de memoire
Ex: portes, MUX, decodeur

🔄

Sequentielle

Sortie = f(entrees + etat precedent)
Memoire (bascules)
Ex: compteurs, registres

8.2 Bascule RS (Set-Reset)

    BASCULE RS A PORTES NOR
    
         R ────┬───[≥1]────┬─── Q
               │           │
               └─────×─────┘
                     │
               ┌─────×─────┐
               │           │
         S ────┴───[≥1]────┴─── Q̄
    
    
    TABLE DE VERITE
    
     S  R │ Q(t+1)  │ Commentaire
    ──────┼─────────┼─────────────────
     0  0 │  Q(t)   │ Memorisation
     0  1 │   0     │ Reset (RAZ)
     1  0 │   1     │ Set (mise a 1)
     1  1 │   ?     │ INTERDIT
    
    Equation caracteristique : Q(t+1) = S + R̄·Q(t)
    Condition : S·R = 0 (jamais S=R=1 simultanement)
⚠️
Etat interdit S=R=1 Quand S=R=1, les deux sorties Q et Q̄ sont a 0, ce qui viole la condition Q̄ = complement de Q. A eviter !

8.3 Bascule D (Data/Delay)

    BASCULE D (sur front montant)
    
         ┌───────────┐
    D ───┤           ├─── Q
         │     D     │
    CLK ─┤    >      ├─── Q̄
         │           │
         └───────────┘
    
    TABLE DE VERITE (front montant ↑)
    
     CLK │ D │ Q(t+1)
    ─────┼───┼────────
      ↑  │ 0 │   0
      ↑  │ 1 │   1
     autre│ X │  Q(t)   (memorisation)
    
    Equation : Q(t+1) = D
    
    La sortie Q "copie" l'entree D au moment du front d'horloge.
    C'est la bascule la plus utilisee en pratique.

Chronogramme

    CHRONOGRAMME BASCULE D
    
    CLK   ──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──
            └──┘  └──┘  └──┘  └──┘  └──┘
               ↑     ↑     ↑     ↑     ↑
    
    D     ────┐     ┌───────────┐
              └─────┘           └────────
    
    Q     ─────────┐     ┌───────────┐
                   └─────┘           └───
    
    Q change UNIQUEMENT sur les fronts montants (↑)
    Q prend la valeur de D juste AVANT le front

8.4 Bascule JK

    BASCULE JK (sur front montant)
    
         ┌───────────┐
    J ───┤           ├─── Q
         │    JK     │
    K ───┤    >      ├─── Q̄
         │           │
    CLK ─┤           │
         └───────────┘
    
    TABLE DE VERITE (front montant ↑)
    
     J  K │ Q(t+1)  │ Mode
    ──────┼─────────┼────────────
     0  0 │  Q(t)   │ Memorisation
     0  1 │   0     │ Reset
     1  0 │   1     │ Set
     1  1 │  Q̄(t)   │ Toggle (basculement)
    
    Equation caracteristique : Q(t+1) = J·Q̄(t) + K̄·Q(t)
    
    Avantage : PAS D'ETAT INTERDIT (J=K=1 = toggle)
    La bascule JK est la plus "complete"

8.5 Bascule T (Toggle)

    BASCULE T
    
    Cas particulier de JK avec J = K = T
    
     T │ Q(t+1)  │ Mode
    ───┼─────────┼────────────
     0 │  Q(t)   │ Memorisation
     1 │  Q̄(t)   │ Toggle
    
    Equation : Q(t+1) = T ⊕ Q(t)
    
    Application : Diviseur de frequence par 2
    Si T = 1 en permanence, Q change a chaque front
    → Frequence de Q = Frequence CLK / 2

8.6 Entrees Asynchrones

    BASCULE D AVEC PRESET ET CLEAR
    
              /PRE
                │
         ┌──────┴──────┐
    D ───┤             ├─── Q
         │      D      │
    CLK ─┤     >       ├─── Q̄
         │             │
         └──────┬──────┘
                │
              /CLR
    
    /PRE et /CLR sont ASYNCHRONES (independants de CLK)
    Actifs a l'etat BAS (active low)
    
    /PRE │ /CLR │ Effet
    ─────┼──────┼─────────────────
      0  │   1  │ Q = 1 (force)
      1  │   0  │ Q = 0 (force)
      1  │   1  │ Fonctionnement normal
      0  │   0  │ INTERDIT
📦

Chapitre 9 : Registres

Stockage et decalage de donnees

9.1 Registre Parallele

📖
Registre parallele (PIPO) Ensemble de n bascules D partageant la meme horloge. Charge et restitue n bits simultanement. Parallel In, Parallel Out. 
    REGISTRE 4 BITS PARALLELE (PIPO)
    
    D3       D2       D1       D0      (entrees paralleles)
     │        │        │        │
     ▼        ▼        ▼        ▼
    ┌─┴─┐    ┌─┴─┐    ┌─┴─┐    ┌─┴─┐
    │ D │    │ D │    │ D │    │ D │
    │ > │    │ > │    │ > │    │ > │
    └─┬─┘    └─┬─┘    └─┬─┘    └─┬─┘
      │        │        │        │
      └────────┴────────┴────────┴────── CLK
      │        │        │        │
      ▼        ▼        ▼        ▼
     Q3       Q2       Q1       Q0      (sorties paralleles)
    
    Au front d'horloge : Q ← D (les 4 bits simultanement)
    
    Circuit : 74LS175 (4 bascules D), 74LS374 (8 bascules D)

9.2 Registre a Decalage

📖
Registre a decalage (Shift Register) Les bascules sont connectees en serie. A chaque coup d'horloge, les donnees se decalent d'une position. Utilise pour la conversion serie/parallele.

SISO

Serial In, Serial Out
Ligne a retard

SIPO

Serial In, Parallel Out
Conversion serie→parallele

PISO

Parallel In, Serial Out
Conversion parallele→serie

PIPO

Parallel In, Parallel Out
Stockage (registre simple)

9.3 Registre SIPO

    REGISTRE A DECALAGE SIPO 4 BITS
    
                                                    
    Din ──▶┌───┐    ┌───┐    ┌───┐    ┌───┐
           │ D │───▶│ D │───▶│ D │───▶│ D │
           │ > │    │ > │    │ > │    │ > │
           └─┬─┘    └─┬─┘    └─┬─┘    └─┬─┘
             │        │        │        │
    CLK ─────┴────────┴────────┴────────┘
             │        │        │        │
            Q3       Q2       Q1       Q0
    
    
    CHRONOGRAMME (entree serie : 1011)
    
    CLK    ─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─
            └─┘ └─┘ └─┘ └─┘ └─┘
    
    Din    ─1───0───1───1──────────
    
    Q3     ─0───1───0───1───1──────
    Q2     ─0───0───1───0───1──────
    Q1     ─0───0───0───1───0──────
    Q0     ─0───0───0───0───1──────
    
    Apres 4 CLK : Q3Q2Q1Q0 = 1011 (donnee serie convertie en parallele)
    
    Circuit : 74HC595 (SIPO 8 bits avec latch), tres utilise !

9.4 Applications des Registres a Decalage

  • Communication serie : UART, SPI, I²C
  • Extension d'E/S : 74HC595 pour piloter des LEDs, afficheurs
  • Multiplication/Division par 2 : Decalage a gauche/droite
  • Ligne a retard : Retarder un signal de n coups d'horloge
  • Generateur pseudo-aleatoire : LFSR (Linear Feedback Shift Register)
💡
Astuce multiplication Decalage a gauche = multiplication par 2
Decalage a droite = division par 2
Exemple : 0011 (3) decale a gauche → 0110 (6)
🔢

Chapitre 10 : Compteurs

Asynchrones et synchrones

10.1 Compteur Asynchrone (Ripple Counter)

📖
Compteur asynchrone Les bascules sont connectees en cascade : la sortie Q d'une bascule sert d'horloge a la suivante. Simple mais sujet aux glitches (etats transitoires). 
    COMPTEUR ASYNCHRONE 4 BITS
    
                                    
    CLK ──▶┌───┐    ┌───┐    ┌───┐    ┌───┐
           │ T │    │ T │    │ T │    │ T │
           │   │───▶│   │───▶│   │───▶│   │
           └─┬─┘    └─┬─┘    └─┬─┘    └─┬─┘
             │        │        │        │
            Q0       Q1       Q2       Q3
           (LSB)                      (MSB)
    
    Chaque bascule T divise la frequence par 2
    Q0 change a chaque front de CLK
    Q1 change a chaque front de Q0
    etc.
    
    INCONVENIENT : Temps de propagation cumule
    Les bits ne changent pas exactement au meme moment
    → Etats transitoires (glitches)
    
    Circuit : 74LS93 (compteur asynchrone 4 bits)

10.2 Compteur Synchrone

📖
Compteur synchrone Toutes les bascules recoivent la meme horloge. Les changements sont simultanes. Plus complexe mais pas de glitches. 
    COMPTEUR SYNCHRONE 4 BITS (avec bascules JK)
    
    Equations pour chaque bascule :
    
    Q0 : J0 = K0 = 1              (toggle toujours)
    Q1 : J1 = K1 = Q0             (toggle si Q0=1)
    Q2 : J2 = K2 = Q0·Q1          (toggle si Q0=Q1=1)
    Q3 : J3 = K3 = Q0·Q1·Q2       (toggle si Q0=Q1=Q2=1)
    
    TOUTES les bascules recoivent le meme CLK !
    
    
    CHRONOGRAMME
    
    CLK  ─┐┌┐┌┐┌┐┌┐┌┐┌┐┌┐┌┐┌┐┌┐┌┐┌┐┌┐┌┐┌┐┌
          └┘└┘└┘└┘└┘└┘└┘└┘└┘└┘└┘└┘└┘└┘└┘└┘
    
    Q0   ─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌
          └─┘ └─┘ └─┘ └─┘ └─┘ └─┘ └─┘ └─┘
    
    Q1   ───┐   ┌───┐   ┌───┐   ┌───┐   ┌
            └───┘   └───┘   └───┘   └───┘
    
    Q2   ───────┐       ┌───────┐       ┌
                └───────┘       └───────┘
    
    Q3   ───────────────┐               ┌
                        └───────────────┘
    
    Compte: 0 1 2 3 4 5 6 7 8 9 A B C D E F 0...
    
    Circuits : 74LS161, 74LS163 (compteurs synchrones 4 bits)

10.3 Compteur Modulo N

    COMPTEUR MODULO 10 (DECADE / BCD)
    
    Compte de 0 a 9 (0000 a 1001) puis revient a 0
    
    Methode : Detecter l'etat 1010 (10) et forcer RESET
    
    
                    Q3 ──┐
                    Q1 ──┼──[&]──▶ RESET
                         │
    Si Q3=1 ET Q1=1 (etat 1010), alors RESET
    
    
    Alternative : Utiliser un compteur avec chargement
    et detecter 9 pour charger 0
    
    
    COMPTEUR MODULO N QUELCONQUE
    
    Pour modulo 6 (0 a 5) : detecter 110 (6)
    RESET = Q2 · Q1
    
    Circuit dedie : 74LS90 (compteur decade)

10.4 Compteur/Decompteur

    COMPTEUR/DECOMPTEUR (UP/DOWN COUNTER)
    
    Signal UP//DOWN controle le sens de comptage
    
    UP//DOWN = 1 : Comptage (0, 1, 2, 3, ...)
    UP//DOWN = 0 : Decomptage (F, E, D, C, ...)
    
    
    Circuit : 74LS191 (compteur/decompteur synchrone 4 bits)
    
    Entrees :
    - CLK : Horloge
    - UP//DOWN : Sens de comptage
    - LOAD : Chargement parallele
    - EN : Enable
    
    Sorties :
    - Q0-Q3 : Valeur du compteur
    - RCO : Ripple Carry Out (retenue)
    - MAX/MIN : Indicateur de fin de comptage

10.5 Tableau Recapitulatif des Compteurs

CircuitTypeBitsModuloCaracteristiques
74LS90Async410Decade (BCD)
74LS93Async416Binaire
74LS161Sync416Clear async
74LS163Sync416Clear sync
74LS191Sync416Up/Down
74LS193Sync416Up/Down, 2 CLK
🔲

Chapitre 11 : FPGA et CPLD

Circuits logiques programmables

11.1 Evolution des Circuits Programmables

    EVOLUTION DES PLD (Programmable Logic Device)
    
    Annees   Circuit         Capacite        Caracteristiques
    ────────────────────────────────────────────────────────
    1970s    PAL/PLA         ~100 portes     Fusibles, OTP
    1980s    GAL             ~100 portes     Reprogrammable
    1990s    CPLD            ~10k portes     Architecture fixe
    2000s+   FPGA            ~1M+ portes     Architecture flexible
    
    
    PLD → CPLD → FPGA
    
    Complexite croissante ───────────────────────────▶
    Flexibilite croissante ─────────────────────────▶

11.2 CPLD (Complex PLD)

📖
CPLD (Complex Programmable Logic Device) Assemblage de plusieurs blocs logiques (macrocells) interconnectes. Temps de propagation previsible. Non volatile (garde sa configuration). 
    ARCHITECTURE CPLD
    
    ┌─────────────────────────────────────────────────────┐
    │                                                     │
    │  ┌────────┐  ┌────────┐  ┌────────┐  ┌────────┐   │
    │  │Macrocell│  │Macrocell│  │Macrocell│  │Macrocell│   │
    │  │  LAB   │  │  LAB   │  │  LAB   │  │  LAB   │   │
    │  └────┬───┘  └────┬───┘  └────┬───┘  └────┬───┘   │
    │       │           │           │           │        │
    │       └───────────┼───────────┼───────────┘        │
    │                   │           │                    │
    │         ══════════╪═══════════╪══════════          │
    │                   │           │                    │
    │              MATRICE D'INTERCONNEXION              │
    │              (Programmable Interconnect)           │
    │                                                    │
    │  ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐       │
    │  │I/O│I/O│I/O│I/O│I/O│I/O│I/O│I/O│              │
    │  └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘       │
    └─────────────────────────────────────────────────────┘
    
    Avantages :
    - Temps de propagation deterministe
    - Non volatile (Flash/EEPROM)
    - Demarrage instantane
    
    Exemples : Xilinx CoolRunner, Altera MAX II

11.3 FPGA (Field Programmable Gate Array)

📖
FPGA (Field Programmable Gate Array) Matrice de blocs logiques configurables (CLB) et d'interconnexions programmables. Tres grande capacite et flexibilite. Generalement volatile (SRAM). 
    ARCHITECTURE FPGA
    
    ┌─────────────────────────────────────────────────────────┐
    │  I/O   I/O   I/O   I/O   I/O   I/O   I/O   I/O        │
    │   │     │     │     │     │     │     │     │          │
    │ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐      │
    │ │CLB│═│CLB│═│CLB│═│CLB│═│CLB│═│CLB│═│CLB│═│CLB│  I/O │
    │ └─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘      │
    │   ║     ║     ║     ║     ║     ║     ║     ║          │
    │ ┌─╨─┐ ┌─╨─┐ ┌─╨─┐ ┌─╨─┐ ┌─╨─┐ ┌─╨─┐ ┌─╨─┐ ┌─╨─┐      │
    │ │CLB│═│CLB│═│BRAM│═│CLB│═│DSP│═│CLB│═│CLB│═│CLB│  I/O │
    │ └─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘ └─┬─┘      │
    │   ║     ║     ║     ║     ║     ║     ║     ║          │
    │  ...   ...   ...   ...   ...   ...   ...   ...        │
    │                                                        │
    └─────────────────────────────────────────────────────────┘
    
    CLB = Configurable Logic Block (LUT + Flip-Flops)
    BRAM = Block RAM (memoire integree)
    DSP = Digital Signal Processing (multiplieur)
    ═ = Interconnexion programmable

11.4 CLB et LUT

    STRUCTURE D'UN CLB (Configurable Logic Block)
    
    ┌─────────────────────────────────────────────┐
    │                    CLB                       │
    │  ┌──────────────────────────────────────┐   │
    │  │              SLICE                    │   │
    │  │  ┌─────────┐        ┌─────────┐      │   │
    │  │  │  LUT4   │───────▶│    D    │──▶ Q │   │
    │  │  │ (16x1)  │        │   FF    │      │   │
    │  │  └─────────┘        └─────────┘      │   │
    │  │  ┌─────────┐        ┌─────────┐      │   │
    │  │  │  LUT4   │───────▶│    D    │──▶ Q │   │
    │  │  │ (16x1)  │        │   FF    │      │   │
    │  │  └─────────┘        └─────────┘      │   │
    │  └──────────────────────────────────────┘   │
    └─────────────────────────────────────────────┘
    
    LUT (Look-Up Table) :
    - Table de verite programmable
    - LUT4 = 4 entrees → 1 sortie (16 bits de config)
    - Peut implementer N'IMPORTE QUELLE fonction de 4 variables
    
    Exemple : LUT4 pour S = A·B + C·D
    Configuration : table de 16 valeurs stockee en SRAM

11.5 Fabricants et Outils

FabricantFamilles FPGALogiciel
AMD/XilinxSpartan, Artix, ZynqVivado
Intel/AlteraCyclone, MAX 10, ArriaQuartus Prime
LatticeiCE40, ECP5, CrossLinkDiamond, Radiant
MicrochipPolarFire, IGLOO2Libero SoC
💡
Cartes de developpement populaires
  • Digilent Basys 3 (Artix-7 - Xilinx)
  • Terasic DE10-Lite (MAX 10 - Intel)
  • Lattice iCEstick (iCE40)
💻

Chapitre 12 : Introduction au VHDL

Langage de description materielle

12.1 Qu'est-ce que le VHDL ?

📖
VHDL (VHSIC Hardware Description Language) Langage de description materielle normalise (IEEE 1076). Permet de decrire le comportement et la structure des circuits numeriques pour simulation et synthese sur FPGA/CPLD.
  • VHSIC = Very High Speed Integrated Circuit
  • Developpe dans les annees 1980 pour le DoD americain
  • Normalise IEEE 1076 (1987, 1993, 2008)
  • Concurrent principal : Verilog

12.2 Structure d'un Programme VHDL

-- Declaration des bibliotheques
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

-- ENTITE : Interface externe (ports d'E/S)
entity nom_circuit is
    port (
        entree1 : in  STD_LOGIC;
        entree2 : in  STD_LOGIC;
        sortie  : out STD_LOGIC
    );
end nom_circuit;

-- ARCHITECTURE : Description du fonctionnement interne
architecture comportement of nom_circuit is
    -- Declarations internes (signaux, constantes)
begin
    -- Instructions concurrentes
    sortie <= entree1 and entree2;
end comportement;

12.3 Types de Donnees

TypeDescriptionValeurs
STD_LOGIC1 bit logique'0', '1', 'Z', 'X', '-'
STD_LOGIC_VECTORBus de n bits"1010", "00FF"
BIT1 bit simple'0', '1'
INTEGEREntier-2³¹ a 2³¹-1
BOOLEANBooleenTRUE, FALSE
UNSIGNEDEntier non signeArithmetique
SIGNEDEntier signeComplement a 2

12.4 Operateurs Logiques

-- Operateurs logiques de base
S1 <= A and B;      -- ET
S2 <= A or B;       -- OU
S3 <= not A;        -- NON
S4 <= A nand B;     -- NON-ET
S5 <= A nor B;      -- NON-OU
S6 <= A xor B;      -- OU exclusif
S7 <= A xnor B;     -- NON-OU exclusif

12.5 Instructions Concurrentes

Affectation conditionnelle (WHEN...ELSE)

-- Multiplexeur 2 vers 1
Y <= A when SEL = '0' else B;

-- Multiplexeur 4 vers 1
Y <= D0 when SEL = "00" else
     D1 when SEL = "01" else
     D2 when SEL = "10" else
     D3;

Selection (WITH...SELECT)

-- Decodeur 7 segments
with BCD select
    SEG <= "1111110" when "0000",  -- 0
           "0110000" when "0001",  -- 1
           "1101101" when "0010",  -- 2
           "1111001" when "0011",  -- 3
           "0000000" when others;

12.6 Process (Instructions Sequentielles)

-- Bascule D avec reset asynchrone
process(CLK, RST)
begin
    if RST = '1' then
        Q <= '0';
    elsif rising_edge(CLK) then
        Q <= D;
    end if;
end process;


-- Compteur 4 bits
process(CLK, RST)
begin
    if RST = '1' then
        count <= "0000";
    elsif rising_edge(CLK) then
        count <= count + 1;
    end if;
end process;

12.7 Exemple Complet : Compteur 4 bits

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

entity compteur_4bits is
    port (
        CLK   : in  STD_LOGIC;
        RST   : in  STD_LOGIC;
        EN    : in  STD_LOGIC;
        COUNT : out STD_LOGIC_VECTOR(3 downto 0)
    );
end compteur_4bits;

architecture rtl of compteur_4bits is
    signal cnt : unsigned(3 downto 0) := "0000";
begin
    process(CLK, RST)
    begin
        if RST = '1' then
            cnt <= "0000";
        elsif rising_edge(CLK) then
            if EN = '1' then
                cnt <= cnt + 1;
            end if;
        end if;
    end process;
    
    COUNT <= std_logic_vector(cnt);
end rtl;

12.8 Resume VHDL

📝
Points cles a retenir
  • Entity = Interface (ports E/S)
  • Architecture = Description interne
  • Concurrent = Instructions executees en parallele
  • Process = Instructions sequentielles (IF, CASE)
  • rising_edge(CLK) = Front montant
  • <= = Affectation de signal

Cours Systemes Numeriques - S01 Traitement Numerique

12 Chapitres | Numeration - Logique Combinatoire - Logique Sequentielle - VHDL

🔧

Chapitre 7 : Circuits Combinatoires

Decodeurs, multiplexeurs, additionneurs

7.1 Decodeur

📖
Decodeur n vers 2n Circuit avec n entrees et 2n sorties. Une seule sortie est active a la fois, correspondant a la valeur binaire des entrees. 
    DECODEUR 2 VERS 4 (74LS139)
    
         ┌─────────────┐
    A ───┤             ├─── Y0 (= Ā·B̄)
    B ───┤   DECODEUR  ├─── Y1 (= Ā·B)
    E ───┤    2 → 4    ├─── Y2 (= A·B̄)
         │             ├─── Y3 (= A·B)
         └─────────────┘
    
    TABLE DE VERITE :
    E  A  B │ Y0  Y1  Y2  Y3
    ────────┼────────────────
    1  X  X │  1   1   1   1   (desactive)
    0  0  0 │  0   1   1   1
    0  0  1 │  1   0   1   1
    0  1  0 │  1   1   0   1
    0  1  1 │  1   1   1   0
    
    Sorties actives a l'etat BAS (logique negative)
    
    Usage : Decodage d'adresses memoire (74LS138 = 3→8)

7.2 Encodeur (Codeur)

Fonction inverse du decodeur : 2n entrees → n sorties.

    ENCODEUR PRIORITAIRE 8 VERS 3 (74LS148)
    
    8 entrees (une seule active) → 3 sorties binaires
    
    Entree active │ Sortie (A2 A1 A0)
    ──────────────┼───────────────────
        I0        │     0  0  0
        I1        │     0  0  1
        I2        │     0  1  0
        I3        │     0  1  1
        I4        │     1  0  0
        I5        │     1  0  1
        I6        │     1  1  0
        I7        │     1  1  1
    
    Prioritaire : Si plusieurs entrees actives,
    l'entree de plus haut indice a la priorite.

7.3 Multiplexeur (MUX)

📖
Multiplexeur 2n vers 1 Selectionne une entree parmi 2n et la transmet vers la sortie unique. Les n bits de selection determinent quelle entree est choisie. 
    MULTIPLEXEUR 4 VERS 1 (74LS153)
    
         ┌─────────────┐
    D0 ──┤             │
    D1 ──┤     MUX     │
    D2 ──┤    4 → 1    ├─── Y
    D3 ──┤             │
         ├─────────────┤
    S1 ──┤  SELECTION  │
    S0 ──┤             │
         └─────────────┘
    
    TABLE DE VERITE :
    S1  S0 │ Y
    ───────┼────
    0   0  │ D0
    0   1  │ D1
    1   0  │ D2
    1   1  │ D3
    
    Equation : Y = D0·S̄1·S̄0 + D1·S̄1·S0 + D2·S1·S̄0 + D3·S1·S0
    
    Usage : Selection de donnees, routage de signaux

7.4 Demultiplexeur (DEMUX)

Inverse du MUX : 1 entree vers 2n sorties. Equivalent a un decodeur avec entree de donnees.

    DEMULTIPLEXEUR 1 VERS 4
    
         ┌─────────────┐
    D ────┤    DEMUX    ├─── Y0
         │    1 → 4    ├─── Y1
    S1 ──┤             ├─── Y2
    S0 ──┤             ├─── Y3
         └─────────────┘
    
    S1  S0 │ Y0    Y1    Y2    Y3
    ───────┼─────────────────────
    0   0  │  D     0     0     0
    0   1  │  0     D     0     0
    1   0  │  0     0     D     0
    1   1  │  0     0     0     D

7.5 Additionneur

Demi-additionneur (Half Adder)

    DEMI-ADDITIONNEUR (2 entrees, pas de retenue entrante)
    
    A  B │ S (Somme)  C (Retenue)
    ─────┼─────────────────────────
    0  0 │     0           0
    0  1 │     1           0
    1  0 │     1           0
    1  1 │     0           1
    
    Equations : S = A ⊕ B     (XOR)
                C = A · B      (AND)
    
    Schema :
    A ──┬────[XOR]──── S
        │
    B ──┼────[AND]──── C
        │

Additionneur complet (Full Adder)

    ADDITIONNEUR COMPLET (avec retenue entrante Cin)
    
    A  B  Cin │ S   Cout
    ──────────┼──────────
    0  0   0  │ 0    0
    0  0   1  │ 1    0
    0  1   0  │ 1    0
    0  1   1  │ 0    1
    1  0   0  │ 1    0
    1  0   1  │ 0    1
    1  1   0  │ 0    1
    1  1   1  │ 1    1
    
    Equations : S = A ⊕ B ⊕ Cin
                Cout = A·B + Cin·(A ⊕ B)
    
    
    ADDITIONNEUR 4 BITS (cascade de Full Adders)
    
        A3 B3       A2 B2       A1 B1       A0 B0
         │  │        │  │        │  │        │  │
        ┌┴──┴┐      ┌┴──┴┐      ┌┴──┴┐      ┌┴──┴┐
    C4←─┤ FA │←─C3──┤ FA │←─C2──┤ FA │←─C1──┤ FA │←─C0=0
        └──┬─┘      └──┬─┘      └──┬─┘      └──┬─┘
           S3          S2          S1          S0
    
    Circuit integre : 74LS283 (additionneur 4 bits)

7.6 Comparateur

    COMPARATEUR 4 BITS (74LS85)
    
    Compare deux nombres A et B de 4 bits
    
         ┌─────────────────┐
    A3 ──┤                 ├─── A > B
    A2 ──┤                 │
    A1 ──┤   COMPARATEUR   ├─── A = B
    A0 ──┤                 │
    B3 ──┤     4 BITS      ├─── A < B
    B2 ──┤                 │
    B1 ──┤                 │
    B0 ──┤                 │
         └─────────────────┘
    
    Entrees de cascade pour extension a plus de 4 bits
🔄

Chapitre 8 : Bascules (Flip-Flops)

RS, D, JK, T - Logique sequentielle

🎯 Objectifs du chapitre

  • Distinguer logique combinatoire et sequentielle
  • Comprendre le fonctionnement des bascules
  • Maitriser les tables de transition
  • Analyser les chronogrammes

8.1 Logique Combinatoire vs Sequentielle

⚡

Combinatoire

Sorties = f(Entrees)
Pas de memoire
Decodeurs, MUX, portes

🔄

Sequentielle

Sorties = f(Entrees, Etat)
Memoire (bascules)
Compteurs, registres

8.2 Bascule RS (Reset-Set)

    BASCULE RS ASYNCHRONE (verrou RS / RS Latch)
    
    Realisee avec 2 portes NOR :
    
         R ──┬──[≥1]──┬── Q
             │        │
             └────────┤
                      │
             ┌────────┘
             │        │
         S ──┴──[≥1]──┴── Q̄
    
    TABLE DE VERITE :
    S  R │ Q(t+1) │ Mode
    ─────┼────────┼─────────────
    0  0 │  Q(t)  │ Memorisation
    0  1 │   0    │ Reset (RAZ)
    1  0 │   1    │ Set (mise a 1)
    1  1 │   ?    │ INTERDIT !
    
    Equation : Q(t+1) = S + R̄·Q(t)   avec S·R = 0
    
    ⚠️ L'etat S=R=1 est interdit (instable)

8.3 Bascule D (Data / Delay)

    BASCULE D (la plus utilisee)
    
    Symbole :
         ┌─────────┐
    D ───┤ D     Q ├─── Q
         │         │
    CLK ─┤ >    Q̄ ├─── Q̄
         └─────────┘
    
    TABLE DE VERITE (front montant ↑) :
    CLK │ D │ Q(t+1)
    ────┼───┼───────
     ↑  │ 0 │   0
     ↑  │ 1 │   1
    
    Equation : Q(t+1) = D
    
    La sortie Q prend la valeur de D au front d'horloge
    et la maintient jusqu'au prochain front.
    
    "D" comme "Data" ou "Delay" (retard d'un cycle)
    
    Circuit integre : 74LS74 (double bascule D)
💡
Front d'horloge
  • Front montant (↑) : Transition 0 → 1
  • Front descendant (↓) : Transition 1 → 0
  • La bascule ne reagit qu'au moment du front, pas aux niveaux

8.4 Bascule JK

    BASCULE JK (la plus versatile)
    
    Symbole :
         ┌─────────┐
    J ───┤ J     Q ├─── Q
         │         │
    CLK ─┤ >    Q̄ ├─── Q̄
         │         │
    K ───┤ K       │
         └─────────┘
    
    TABLE DE VERITE (front montant ↑) :
    J  K │ Q(t+1) │ Mode
    ─────┼────────┼─────────────
    0  0 │  Q(t)  │ Memorisation
    0  1 │   0    │ Reset
    1  0 │   1    │ Set
    1  1 │  Q̄(t)  │ Basculement (Toggle)
    
    Equation : Q(t+1) = J·Q̄(t) + K̄·Q(t)
    
    Avantage : Pas d'etat interdit !
    Le mode J=K=1 bascule (toggle) a chaque front.
    
    Circuit integre : 74LS76 (double bascule JK)

8.5 Bascule T (Toggle)

    BASCULE T (Trigger / Toggle)
    
    TABLE DE VERITE :
    T │ Q(t+1)
    ──┼────────
    0 │  Q(t)    Memorisation
    1 │  Q̄(t)    Basculement
    
    Equation : Q(t+1) = T ⊕ Q(t)
    
    Realisation : Bascule JK avec J = K = T
    
    Usage principal : Division de frequence
    Avec T=1 permanent, la sortie Q change a chaque front
    → Frequence divisee par 2

8.6 Chronogrammes

    CHRONOGRAMME BASCULE D (front montant)
    
    CLK   ──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──
            └──┘  └──┘  └──┘  └──┘  └──┘
               ↑     ↑     ↑     ↑     ↑
    
    D     ─────────┐     ┌─────────┐
                   └─────┘         └─────────
    
    Q     ────────────────┐     ┌─────────┐
                          └─────┘         └──
    
    Q prend la valeur de D a chaque front montant (↑)
    
    
    CHRONOGRAMME BASCULE T (T=1 permanent)
    
    CLK   ──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──
            └──┘  └──┘  └──┘  └──┘  └──┘
    
    Q     ────┐     ┌─────┐     ┌─────┐
              └─────┘     └─────┘     └────
    
    La frequence de Q = frequence CLK / 2

8.7 Entrees Asynchrones

    ENTREES DE FORCAGE ASYNCHRONES
    
         ┌─────────────┐
    /PRE ┤             │   PRE = Preset (mise a 1)
         │             │   CLR = Clear (mise a 0)
    D ───┤ D         Q ├── Q
         │             │   Ces entrees agissent
    CLK ─┤ >        Q̄ ├── Q̄  INDEPENDAMMENT de l'horloge
         │             │
    /CLR ┤             │   Priorite : /PRE et /CLR > CLK
         └─────────────┘
    
    /PRE  /CLR │ Q    │ Mode
    ──────────┼──────┼─────────────────
      0    1  │  1   │ Forcage a 1
      1    0  │  0   │ Forcage a 0
      1    1  │ f(D) │ Fonctionnement normal
      0    0  │  ?   │ INTERDIT
    
    Les "/" indiquent des entrees actives a l'etat bas
📦

Chapitre 9 : Registres

Stockage et decalage de donnees

9.1 Registre de Memorisation (PIPO)

📖
Registre PIPO (Parallel In, Parallel Out) Ensemble de n bascules D partageant la meme horloge. Memorise n bits en parallele au front d'horloge et les restitue en parallele. 
    REGISTRE 4 BITS PIPO
    
    D3──┤D  Q├──Q3      D2──┤D  Q├──Q2
        │  > │              │  > │
    CLK─┤    │          CLK─┤    │
        └────┘              └────┘
    
    D1──┤D  Q├──Q1      D0──┤D  Q├──Q0
        │  > │              │  > │
    CLK─┤    │          CLK─┤    │
        └────┘              └────┘
    
    Au front d'horloge : Q3Q2Q1Q0 ← D3D2D1D0
    
    Circuit integre : 74LS374 (registre 8 bits avec 3-state)

9.2 Registre a Decalage (Shift Register)

    REGISTRE A DECALAGE SISO (Serial In, Serial Out)
    
           ┌────┐    ┌────┐    ┌────┐    ┌────┐
    Sin ──▶│ D  │──▶│ D  │──▶│ D  │──▶│ D  │──▶ Sout
           │  Q │    │  Q │    │  Q │    │  Q │
      CLK ─┤ >  │───┤ >  │───┤ >  │───┤ >  │
           └────┘    └────┘    └────┘    └────┘
             Q3        Q2        Q1        Q0
    
    A chaque front d'horloge :
    - Q0 ← Q1
    - Q1 ← Q2
    - Q2 ← Q3
    - Q3 ← Sin
    
    Les donnees "glissent" vers la droite

Types de registres a decalage

TypeEntreeSortieUsage
SISOSerieSerieLigne a retard
SIPOSerieParalleleConversion serie → parallele
PISOParalleleSerieConversion parallele → serie
PIPOParalleleParalleleMemorisation

9.3 Registre SIPO (74HC595)

    74HC595 - REGISTRE A DECALAGE SIPO 8 BITS
    
    Tres utilise pour etendre les sorties d'un microcontroleur
    
         ┌────────────────────┐
    SER ─┤ Entree serie       │──── QA
         │                    │──── QB
    SRCLK┤ Horloge decalage   │──── QC
         │                    │──── QD    8 sorties
    RCLK ┤ Horloge latch      │──── QE    paralleles
         │                    │──── QF
    /OE ─┤ Output Enable      │──── QG
         │                    │──── QH
    /SRCLR┤ Clear            ├──── QH' (cascade)
         └────────────────────┘
    
    Principe :
    1. Envoyer 8 bits en serie (SER + SRCLK)
    2. Valider vers les sorties (RCLK)
    
    Double registre : decalage + latch de sortie
    Permet de charger les donnees sans "glitch" sur les sorties

9.4 Applications des Registres

  • Memorisation temporaire : Buffer de donnees
  • Conversion serie/parallele : UART, SPI, I2C
  • Multiplication/Division : Decalage = × ou ÷ par 2
  • Extension d'E/S : 74HC595 pour LEDs, afficheurs
  • Generateur de sequences : Registre a retroaction (LFSR)
💡
Decalage et multiplication
  • Decalage a gauche d'1 position = multiplication par 2
  • Decalage a droite d'1 position = division par 2
🔢

Chapitre 10 : Compteurs

Asynchrones et synchrones

10.1 Compteur Asynchrone (Ripple Counter)

    COMPTEUR ASYNCHRONE 4 BITS
    
    Les bascules sont en cascade : Q de l'une → CLK de la suivante
    
                    ┌────┐     ┌────┐     ┌────┐     ┌────┐
    CLK ───────────▶│ T  │────▶│ T  │────▶│ T  │────▶│ T  │
                    │  Q │     │  Q │     │  Q │     │  Q │
                    └──┬─┘     └──┬─┘     └──┬─┘     └──┬─┘
                       Q0         Q1         Q2         Q3
                      (LSB)                            (MSB)
    
    Chaque bascule T divise la frequence par 2
    
    Sequence : 0000 → 0001 → 0010 → ... → 1111 → 0000
    
    ⚠️ INCONVENIENT : Les sorties ne changent pas simultanement
    → Delai de propagation cumule (ripple = ondulation)
    → Etats transitoires errones (glitches)
    
    Circuit integre : 74LS93 (compteur 4 bits)

10.2 Compteur Synchrone

📖
Compteur synchrone Toutes les bascules recoivent le meme signal d'horloge. Les transitions sont simultanees, pas de glitches. Plus complexe mais plus fiable. 
    COMPTEUR SYNCHRONE 4 BITS (avec bascules JK)
    
    Toutes les bascules ont la MEME horloge !
    La logique combinatoire controle J et K.
    
    Equations de controle :
    J0 = K0 = 1           (Q0 bascule toujours)
    J1 = K1 = Q0          (Q1 bascule si Q0=1)
    J2 = K2 = Q0·Q1       (Q2 bascule si Q0=Q1=1)
    J3 = K3 = Q0·Q1·Q2    (Q3 bascule si Q0=Q1=Q2=1)
    
                       ┌─AND─┐
    Q0──┬──────────────┤     ├──J3,K3
        │    ┌─AND─┐   │     │
    Q1──┼────┤     ├───┤     │
        │    │     │   └─────┘
    Q2──┼────┤     │
        │    └─────┴───J2,K2
        │
        └──────────────J1,K1
    
    1 ─────────────────J0,K0
    
    Circuit integre : 74LS161 (compteur 4 bits synchrone)

10.3 Compteur Modulo N

    COMPTEUR MODULO 10 (Compteur decade / BCD)
    
    Compte de 0 a 9 puis revient a 0
    
    Methode : Detecter 10 (1010) et forcer RESET
    
    Detection : Q3·Q1 = 1 quand compte = 10
    (car 10 = 1010, Q3=1 et Q1=1)
    
               Q3 ──┬──[AND]──── /CLR (Reset asynchrone)
               Q1 ──┘
    
    Sequence : 0→1→2→3→4→5→6→7→8→9→(10→0)
    
    Le compteur passe tres brievement par 10
    avant d'etre remis a 0.
    
    Circuit integre : 74LS90 (compteur decade)
    
    
    COMPTEUR MODULO N (generalisation)
    
    Pour compter de 0 a N-1 :
    1. Utiliser un compteur ≥ N
    2. Detecter N avec portes AND
    3. Connecter a l'entree RESET

10.4 Compteur/Decompteur

CircuitTypeBitsFonctions
74LS90Asynchrone4Decade (mod 10)
74LS93Asynchrone4Binaire
74LS161Synchrone4Binaire + Load
74LS163Synchrone4Binaire + Clear sync
74LS191Synchrone4Up/Down binaire
74LS192Synchrone4Up/Down decade

10.5 Chronogramme d'un Compteur 3 bits

    CHRONOGRAMME COMPTEUR 3 BITS (0 a 7)
    
    CLK  ─┐ ┌┐ ┌┐ ┌┐ ┌┐ ┌┐ ┌┐ ┌┐ ┌┐ ┌─
           └┘ └┘ └┘ └┘ └┘ └┘ └┘ └┘ └┘
    
    Q0   ─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─
           └─┘ └─┘ └─┘ └─┘ └─┘
    
    Q1   ───┐   ┌───┐   ┌───┐   ┌─
             └───┘   └───┘   └───┘
    
    Q2   ───────┐       ┌───────┐
                 └───────┘       └─
    
    Valeur  0  1  2  3  4  5  6  7  0  1  2
    
    Q0 : frequence CLK / 2
    Q1 : frequence CLK / 4
    Q2 : frequence CLK / 8
🔲

Chapitre 11 : FPGA et CPLD

Circuits logiques programmables

11.1 Evolution des Circuits Programmables

    EVOLUTION DES PLD (Programmable Logic Device)
    
    1970s        1980s         1990s         2000s+
      │            │             │             │
      ▼            ▼             ▼             ▼
    ┌────┐      ┌────┐       ┌──────┐      ┌──────┐
    │PAL │ ───▶ │GAL │ ───▶  │ CPLD │ ───▶ │ FPGA │
    │    │      │    │       │      │      │      │
    └────┘      └────┘       └──────┘      └──────┘
    
    PAL  : Programmable Array Logic (fusibles, OTP)
    GAL  : Generic Array Logic (EEPROM, reprogrammable)
    CPLD : Complex PLD (plusieurs blocs PAL + interconnexions)
    FPGA : Field Programmable Gate Array (millions de portes)

11.2 Architecture CPLD

📖
CPLD (Complex Programmable Logic Device) Assemblage de plusieurs blocs logiques (macrocells) interconnectes par une matrice programmable. Temps de propagation previsible. Configuration stockee en memoire non volatile (Flash). 
    ARCHITECTURE CPLD
    
    ┌─────────────────────────────────────────────────┐
    │                                                 │
    │   ┌─────────┐    MATRICE      ┌─────────┐     │
    │   │ BLOC 1  │  D'INTERCON-    │ BLOC 2  │     │
    │   │(16 macro│◀═══NEXION══════▶│(16 macro│     │
    │   │ cells)  │  PROGRAMMABLE   │ cells)  │     │
    │   └────┬────┘                 └────┬────┘     │
    │        │                           │          │
    │   ┌────┴────┐                 ┌────┴────┐     │
    │   │   I/O   │                 │   I/O   │     │
    │   │  Block  │                 │  Block  │     │
    │   └─────────┘                 └─────────┘     │
    │        ↕                           ↕          │
    └────────╫───────────────────────────╫──────────┘
             ║                           ║
          Broches                     Broches
    
    Fabricants : Xilinx (CoolRunner), Altera/Intel (MAX)
    Capacite : quelques centaines a quelques milliers de portes

11.3 Architecture FPGA

📖
FPGA (Field Programmable Gate Array) Matrice de blocs logiques configurables (CLB) entoures de blocs d'entrees/sorties (IOB), relies par un reseau d'interconnexions programmables. Configuration en SRAM (volatile) ou Flash. 
    ARCHITECTURE FPGA
    
    ┌────────────────────────────────────────────────┐
    │  IOB   IOB   IOB   IOB   IOB   IOB   IOB      │
    │ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐    │
    │ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘    │
    │                                               │
    │  ┌───┐ ══ ┌───┐ ══ ┌───┐ ══ ┌───┐            │
    │  │CLB│    │CLB│    │CLB│    │CLB│   IOB      │
    │  └───┘    └───┘    └───┘    └───┘            │
    │    ║        ║        ║        ║              │
    │  ┌───┐    ┌───┐    ┌────┐   ┌───┐            │
    │  │CLB│    │CLB│    │BRAM│   │CLB│   IOB      │
    │  └───┘    └───┘    └────┘   └───┘            │
    │    ║        ║        ║        ║              │
    │  ┌───┐    ┌────┐   ┌───┐    ┌───┐            │
    │  │CLB│    │DSP │   │CLB│    │CLB│   IOB      │
    │  └───┘    └────┘   └───┘    └───┘            │
    │                                               │
    └────────────────────────────────────────────────┘
    
    CLB  = Configurable Logic Block (LUT + Flip-Flops)
    IOB  = Input/Output Block
    BRAM = Block RAM (memoire integree)
    DSP  = Digital Signal Processing block
    ══   = Interconnexions programmables

11.4 Comparaison CPLD vs FPGA

CritereCPLDFPGA
Capacite100 - 10K portes10K - 10M portes
ConfigurationFlash (non volatile)SRAM (volatile) ou Flash
DemarrageInstantaneNecessite chargement
TimingPrevisibleVariable selon routage
RessourcesLogique pureRAM, DSP, PLL...
ConsommationFaiblePlus elevee
CoutFaibleVariable (eleve pour gros)
UsageGlue logic, decodageTraitement complexe

11.5 Fabricants et Outils

FabricantFPGALogiciel
AMD/XilinxSpartan, Artix, Kintex, Virtex, ZynqVivado, ISE
Intel/AlteraCyclone, MAX, Arria, StratixQuartus Prime
LatticeiCE40, ECP5, CrossLinkDiamond, Radiant
MicrochipPolarFire, IGLOO, SmartFusionLibero SoC
💻

Chapitre 12 : Introduction au VHDL

Langage de description materielle

12.1 Qu'est-ce que le VHDL ?

📖
VHDL (VHSIC Hardware Description Language) Langage normalise (IEEE 1076) pour decrire le comportement et la structure des circuits numeriques. Utilise pour la simulation et la synthese sur FPGA/CPLD.
  • VHSIC = Very High Speed Integrated Circuit
  • Concurrent (parallele) comme le materiel
  • Fortement type
  • Insensible a la casse (maj/min)

12.2 Structure d'un Programme VHDL

-- Inclusion des bibliotheques
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

-- ENTITE : Interface externe (ports)
entity nom_circuit is
    port (
        entree1 : in  STD_LOGIC;
        entree2 : in  STD_LOGIC;
        sortie  : out STD_LOGIC
    );
end nom_circuit;

-- ARCHITECTURE : Description interne
architecture comportement of nom_circuit is
begin
    sortie <= entree1 and entree2;
end comportement;

12.3 Types de Donnees

TypeDescriptionExemple
STD_LOGIC1 bit (9 etats possibles)'0', '1', 'Z', 'X'
STD_LOGIC_VECTORBus de n bits"1010", "00FF"
BIT1 bit simple'0', '1'
INTEGEREntier0, -5, 255
BOOLEANVrai/FauxTRUE, FALSE
💡
STD_LOGIC : 9 etats '0' (fort), '1' (fort), 'Z' (haute impedance), 'X' (inconnu), 'U' (non initialise), 'W' (faible inconnu), 'L' (faible 0), 'H' (faible 1), '-' (don't care)

12.4 Exemple : Porte ET

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity porte_et is
    port (
        A : in  STD_LOGIC;
        B : in  STD_LOGIC;
        S : out STD_LOGIC
    );
end porte_et;

architecture comportement of porte_et is
begin
    S <= A and B;
end comportement;

12.5 Exemple : Bascule D

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity bascule_D is
    port (
        CLK : in  STD_LOGIC;
        RST : in  STD_LOGIC;
        D   : in  STD_LOGIC;
        Q   : out STD_LOGIC
    );
end bascule_D;

architecture comportement of bascule_D is
begin
    process(CLK, RST)
    begin
        if RST = '1' then
            Q <= '0';
        elsif rising_edge(CLK) then
            Q <= D;
        end if;
    end process;
end comportement;

12.6 Exemple : Compteur 4 bits

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

entity compteur_4bits is
    port (
        CLK   : in  STD_LOGIC;
        RST   : in  STD_LOGIC;
        EN    : in  STD_LOGIC;
        COUNT : out STD_LOGIC_VECTOR(3 downto 0)
    );
end compteur_4bits;

architecture comportement of compteur_4bits is
    signal cnt : unsigned(3 downto 0) := "0000";
begin
    process(CLK, RST)
    begin
        if RST = '1' then
            cnt <= "0000";
        elsif rising_edge(CLK) then
            if EN = '1' then
                cnt <= cnt + 1;
            end if;
        end if;
    end process;
    
    COUNT <= std_logic_vector(cnt);
end comportement;

12.7 Instructions Concurrentes vs Sequentielles

⚡

Concurrent

Hors process
<= affectation signal
when...else, with...select

📝

Sequentiel

Dans un process
if...then...else
case...when, for...loop

-- Instruction CONCURRENTE (hors process)
Y <= A when SEL = '0' else B;

-- Instruction SEQUENTIELLE (dans process)
process(SEL, A, B)
begin
    if SEL = '0' then
        Y <= A;
    else
        Y <= B;
    end if;
end process;