Systemes Numeriques

🔢

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 = a_n×Bⁿ + a_n-1×B^n-1 + ... + a₁×B¹ + a₀×B⁰

1.2 Les Quatre Bases Principales

Base	Nom	Symboles	Prefixe C	Usage
2	Binaire	0, 1	`0b`	Circuits numeriques
8	Octal	0-7	`0`	Unix (permissions)
10	Decimal	0-9	aucun	Usage courant
16	Hexadecimal	0-9, A-F	`0x`	Adresses memoire

Correspondance Hexadecimal

Hex	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
Dec	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
Bin	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111

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

Decimal	Binaire	Octal	Hexadecimal
0	0000 0000	000	00
10	0000 1010	012	0A
25	0001 1001	031	19
100	0110 0100	144	64
127	0111 1111	177	7F
255	1111 1111	377	FF

📝

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 -2^n-1 a +2^n-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)

Bits	Non signe	Signe (C2)
8	0 a 255	-128 a +127
16	0 a 65 535	-32 768 a +32 767
32	0 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

Caractere	ASCII (Dec)	ASCII (Hex)	Binaire
'0'	48	0x30	0011 0000
'9'	57	0x39	0011 1001
'A'	65	0x41	0100 0001
'Z'	90	0x5A	0101 1010
'a'	97	0x61	0110 0001
'z'	122	0x7A	0111 1010
Espace	32	0x20	0010 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)
A	B	A·B
0	0	0
0	1	0
1	0	0
1	1	1

OU (OR)
A	B	A+B
0	0	0
0	1	1
1	0	1
1	1	1

XOR
A	B	A⊕B
0	0	0
0	1	1
1	0	1
1	1	0

4.2 Operateurs Complementaires

NAND (NON-ET)
A	B	A↑B
0	0	1
0	1	1
1	0	1
1	1	0

NOR (NON-OU)
A	B	A↓B
0	0	1
0	1	0
1	0	0
1	1	0

⚡

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

Propriete	Forme ET	Forme OU
Identite	A · 1 = A	A + 0 = A
Element nul	A · 0 = 0	A + 1 = 1
Idempotence	A · A = A	A + A = A
Complementation	A · Ā = 0	A + Ā = 1
Involution	A̿ = A
Commutativite	A · B = B · A	A + B = B + A
Associativite	(A·B)·C = A·(B·C)	(A+B)+C = A+(B+C)
Distributivite	A·(B+C) = A·B + A·C	A+(B·C) = (A+B)·(A+C)
Absorption	A·(A+B) = A	A + 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 2ⁿ : 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

Reference	Fonction	Portes	Entrees
`74LS00`	NAND	4	2
`74LS02`	NOR	4	2
`74LS04`	NOT	6	1
`74LS08`	AND	4	2
`74LS32`	OR	4	2
`74LS86`	XOR	4	2
`74LS10`	NAND	3	3
`74LS20`	NAND	2	4

💡

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

📖

Decodeur n vers 2ⁿ Circuit avec n entrees et 2ⁿ 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 : 2ⁿ 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 2ⁿ vers 1 Selectionne une entree parmi 2ⁿ 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 2ⁿ 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

Type	Entree	Sortie	Usage
SISO	Serie	Serie	Ligne a retard
SIPO	Serie	Parallele	Conversion serie → parallele
PISO	Parallele	Serie	Conversion parallele → serie
PIPO	Parallele	Parallele	Memorisation

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

Circuit	Type	Bits	Fonctions
`74LS90`	Asynchrone	4	Decade (mod 10)
`74LS93`	Asynchrone	4	Binaire
`74LS161`	Synchrone	4	Binaire + Load
`74LS163`	Synchrone	4	Binaire + Clear sync
`74LS191`	Synchrone	4	Up/Down binaire
`74LS192`	Synchrone	4	Up/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

Critere	CPLD	FPGA
Capacite	100 - 10K portes	10K - 10M portes
Configuration	Flash (non volatile)	SRAM (volatile) ou Flash
Demarrage	Instantane	Necessite chargement
Timing	Previsible	Variable selon routage
Ressources	Logique pure	RAM, DSP, PLL...
Consommation	Faible	Plus elevee
Cout	Faible	Variable (eleve pour gros)
Usage	Glue logic, decodage	Traitement complexe

11.5 Fabricants et Outils

Fabricant	FPGA	Logiciel
AMD/Xilinx	Spartan, Artix, Kintex, Virtex, Zynq	Vivado, ISE
Intel/Altera	Cyclone, MAX, Arria, Stratix	Quartus Prime
Lattice	iCE40, ECP5, CrossLink	Diamond, Radiant
Microchip	PolarFire, IGLOO, SmartFusion	Libero 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

Type	Description	Exemple
`STD_LOGIC`	1 bit (9 etats possibles)	'0', '1', 'Z', 'X'
`STD_LOGIC_VECTOR`	Bus de n bits	"1010", "00FF"
`BIT`	1 bit simple	'0', '1'
`INTEGER`	Entier	0, -5, 255
`BOOLEAN`	Vrai/Faux	TRUE, 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;