Logique Sequentielle - S5

Annee: 2022-2023 (Semestre 5)
Credits: 3 ECTS
Type: Electronique Numerique

---

PART A: PRESENTATION GENERALE

Objectifs du cours

Le cours de Logique Sequentielle approfondit la conception de circuits numeriques dont l'etat depend de l'historique des entrees. Il couvre les machines a etats finis (FSM), la conception synchrone et asynchrone, ainsi que les methodes systematiques de conception de systemes sequentiels complexes. Ce cours est fondamental pour concevoir des controleurs numeriques, des protocoles de communication et des systemes embarques.

Competences visees

• Maitriser les bascules et elements de memorisation
• Concevoir des machines a etats finis (Moore et Mealy)
• Analyser et synthetiser des circuits sequentiels
• Gerer les contraintes temporelles et la synchronisation
• Implementer des controleurs complexes
• Optimiser les codages d'etats

Organisation

• Volume horaire: 32h (CM: 18h, TD: 14h)
• Evaluation: Examen final (70%) + TDs (30%)
• Semestre: 5 (2022-2023)
• Prerequis: Logique combinatoire, algebre de Boole

---

PART B: EXPERIENCE, CONTEXTE ET FONCTION

Contenu pedagogique

1. Elements de Memorisation

Bascules et Latches:

Les circuits sequentiels utilisent des elements memoire pour stocker l'etat.

Latch SR (Set-Reset):

S R | Q  Q'
----|-------
0 0 | Q  Q'  (memorisation)
0 1 | 0  1   (reset)
1 0 | 1  0   (set)
1 1 | X  X   (interdit)

Bascule D (Data):

La plus utilisee en conception synchrone.

• Sur front montant d'horloge: Q = D
• Memorise la valeur de D

Equation caracteristique: Q(t+1) = D(t)

Bascule JK:

J K | Q(t+1)
----|--------
0 0 | Q      (memorisation)
0 1 | 0      (reset)
1 0 | 1      (set)
1 1 | Q'     (toggle)

Bascule T (Toggle):

Quand T=1, la sortie bascule: Q(t+1) = Q'(t)

Contraintes temporelles:

• Setup time (tsu): temps avant front d'horloge ou D doit etre stable
• Hold time (th): temps apres front ou D doit rester stable
• Propagation delay (tpd): delai entre front CLK et changement de Q

2. Machines a Etats Finis (FSM)

FSM de Moore:

Les sorties dependent uniquement de l'etat courant.

Structure:

• Etats
• Transitions (dependent des entrees)
• Sorties (fonction de l'etat uniquement)

Exemple: Detecteur de sequence "101"

Diagramme d'etats Moore:

S0 (init, out=0) --[1]--> S1 (out=0)
S1 --[0]--> S2 (out=0)
S2 --[1]--> S3 (out=1)  // Sequence detectee!
S3 --[x]--> ...

FSM de Mealy:

Les sorties dependent de l'etat ET des entrees.

Avantage: souvent moins d'etats que Moore.

Comparaison:

• Moore: sorties stables (changent seulement sur front d'horloge)
• Mealy: reaction plus rapide (sorties changent avec entrees)

3. Methodologie de Conception

Etapes de conception d'une FSM:

1. Specification: definir le comportement souhaite
2. Diagramme d'etats: representation graphique
3. Table d'etats: forme tabulaire
4. Minimisation: reduire le nombre d'etats
5. Codage d'etats: assigner codes binaires
6. Equations logiques: deriver next-state et output logic
7. Implementation: bascules + portes logiques

Exemple: Controleur de feu tricolore

Etats:

• VERT (30s)
• ORANGE (5s)
• ROUGE (35s)

Entrees: timer, capteur vehicule
Sorties: LED_V, LED_O, LED_R

Table d'etats simplifiee:

Etat actuel | Timer | Etat suivant | Sorties
------------|-------|--------------|----------
VERT        | 0     | VERT         | V=1,O=0,R=0
VERT        | 1     | ORANGE       | V=1,O=0,R=0
ORANGE      | 0     | ORANGE       | V=0,O=1,R=0
ORANGE      | 1     | ROUGE        | V=0,O=1,R=0
ROUGE       | 0     | ROUGE        | V=0,O=0,R=1
ROUGE       | 1     | VERT         | V=0,O=0,R=1

4. Codage d'Etats

Binaire naturel:

• n bits pour 2^n etats
• Exemple 4 etats: 00, 01, 10, 11
• Economie de bascules

One-Hot:

• 1 bascule par etat
• Exemple 4 etats: 0001, 0010, 0100, 1000
• Logique de decodage simplifiee
• Utilise en FPGA

Gray:

• 1 seul bit change entre etats adjacents
• Reduit les aleas (glitches)
• Utile en asynchrone

Exemple 4 etats:

Etat | Binaire | One-Hot | Gray
-----|---------|---------|------
S0   | 00      | 0001    | 00
S1   | 01      | 0010    | 01
S2   | 10      | 0100    | 11
S3   | 11      | 1000    | 10

5. Conception Synchrone

Regles de conception synchrone:

• Toutes les bascules partagent la meme horloge
• Pas de logique combinatoire dans le chemin d'horloge
• Respecter les contraintes setup/hold

Frequence maximale:

fmax = 1 / (tpd_logic + tsu + tskew)

ou:

• tpd_logic: delai combinatoire entre bascules
• tsu: setup time
• tskew: decalage d'horloge (clock skew)

Strategies de reset:

Reset asynchrone:

if (reset = '1') then
    state <= S0;
elsif rising_edge(clk) then
    state <= next_state;
end if;

Avantage: reinitialisation immediate
Inconvenient: peut causer metastabilite

Reset synchrone:

if rising_edge(clk) then
    if (reset = '1') then
        state <= S0;
    else
        state <= next_state;
    end if;
end if;

Avantage: synchronise avec horloge
Inconvenient: delai d'un cycle

6. Compteurs Avances

Compteur modulo-N:

Compte de 0 a N-1 puis revient a 0.

Compteur decimal BCD:
Compte de 0 a 9 (0000 a 1001).

Compteur up/down:

Entree DIR: 1=up, 0=down

Exemple 3 bits up/down:

UP:   000 -> 001 -> 010 -> 011 -> 100 -> 101 -> 110 -> 111 -> 000
DOWN: 111 -> 110 -> 101 -> 100 -> 011 -> 010 -> 001 -> 000 -> 111

Compteur avec prechargement:

Entree LOAD: charge valeur initiale
Utilite: division de frequence precise

7. Aspects Temporels

Metastabilite:

Phenomene lorsque setup/hold time violes.
La bascule peut rester dans etat indetermine.

Solution: Synchroniseur a 2 etages

Entree asynchrone -> [FF1] -> [FF2] -> Sortie synchrone
                       CLK      CLK

Reduit probabilite de metastabilite a ~10^-12.

Analyse de chemin critique:

Identifier le chemin logique le plus long entre deux bascules.

Exemple:

FF1 --[tpd=2ns]--> NAND --[tpd=3ns]--> XOR --[tpd=4ns]--> FF2
                                                          [tsu=1ns]

Delai total: 2 + 3 + 4 + 1 = 10ns
Frequence max: 1/10ns = 100MHz

Supports de cours:
Cours Logique Sequentielle

---

PART C: ASPECTS TECHNIQUES

Exercices de TD

TD1: Conception de FSM

Exercice: Concevoir un detecteur de sequence "1011" (non chevauchant).

Solution:

Etats necessaires:

• S0: etat initial
• S1: apres "1"
• S2: apres "10"
• S3: apres "101"
• S4: sequence complete detectee

Table de transition:

Etat | Entree 0 | Entree 1 | Sortie
-----|----------|----------|--------
S0   | S0       | S1       | 0
S1   | S2       | S1       | 0
S2   | S0       | S3       | 0
S3   | S0       | S4       | 0
S4   | S0       | S1       | 1

TD2: Codage et equations

Pour 4 etats codes en binaire:

• Q1 Q0 = 00 (S0), 01 (S1), 10 (S2), 11 (S3)

Deriver equations next-state avec Karnaugh.

TD3: Analyse temporelle

Calculer frequence maximale d'un circuit avec:

• tpd_FF = 5ns
• tpd_comb = 15ns
• tsu = 3ns
• tskew = 1ns

Solution:
Periode minimale = 5 + 15 + 3 + 1 = 24ns
fmax = 1/24ns = 41.67MHz

Applications Pratiques

Controleur UART (emetteur):

Etats:

• IDLE: attente donnees
• START: envoi bit de start
• DATA0-DATA7: envoi 8 bits de donnees
• STOP: bit de stop
• Retour IDLE

Decodeur de protocole I2C:

FSM detectant:

• Condition START (SDA chute avec SCL=1)
• Adresse (7 bits)
• R/W bit
• ACK/NACK
• Donnees
• Condition STOP (SDA monte avec SCL=1)

Controleur de distributeur automatique:

Entrees: pieces inserees (5c, 10c, 25c)
Sortie: produit delivre si montant atteint

Etats representent le credit accumule.

Outils de Conception

Simulateurs:

• Logisim: simulation graphique
• ModelSim: simulation VHDL/Verilog
• Quartus: suite complete Altera/Intel

Langages de description:

VHDL exemple (FSM Moore):

process(clk, reset)
begin
    if reset = '1' then
        state <= S0;
    elsif rising_edge(clk) then
        case state is
            when S0 =>
                if input = '1' then
                    state <= S1;
                end if;
            when S1 =>
                -- transitions...
        end case;
    end if;
end process;

-- Logique de sortie Moore
output <= '1' when state = S3 else '0';

Verilog exemple (FSM Mealy):

always @(posedge clk or posedge reset) begin
    if (reset)
        state <= S0;
    else
        state <= next_state;
end

// Logique next_state et output (combinatoire)
always @(*) begin
    case (state)
        S0: begin
            if (input)
                next_state = S1;
            output = 1'b0;
        end
        // ...
    endcase
end

---

PART D: ANALYSE ET REFLEXION

Competences acquises

Techniques:

• Conception systematique de FSM
• Optimisation de codage d'etats
• Analyse temporelle de circuits sequentiels
• Gestion de la synchronisation
• Implementation en VHDL/Verilog

Methodologiques:

• Demarche de conception rigoureuse
• Tests et verification de FSM
• Documentation (diagrammes d'etats)
• Debogage de circuits sequentiels

Applications professionnelles

La logique sequentielle est utilisee dans:

• Protocoles de communication: UART, SPI, I2C, USB
• Controleurs: machines, robots, process industriels
• Interfaces: LCD, clavier, souris, touchscreen
• Processeurs: unite de controle, pipelines
• Stockage: controleurs de memoire, cache
• Reseaux: routeurs, switches, protocoles

Connexions avec autres cours

• Fondements Electronique Numerique (S5): base (bascules, compteurs)
• Architectures Numeriques VHDL (S7): implementation FPGA
• Microcontroleurs (S6): FSM dans firmware
• Temps Reel (S8): ordonnancement et synchronisation
• Reseaux (S6): protocoles en couches FSM

Evolution et Perspectives

Outils modernes:

• Synthese automatique depuis FSM graphiques
• Verification formelle (model checking)
• Generation automatique de tests
• Optimisation multi-objectifs (surface/vitesse/consommation)

Tendances:

• FSM hierarchiques (StateCharts)
• FSM concurrentes
• Langages de haut niveau (SystemVerilog, SystemC)
• Synthese de haut niveau (HLS)

Applications emergentes:

• IoT: controleurs ultra-basse consommation
• IA embarquee: FSM pour gestion d'energie
• Automobile: ADAS, controle moteur
• 5G: traitement protocoles temps reel

Recommandations

1. Toujours partir du diagramme d'etats: visualisation essentielle
2. Verifier tous les cas: etats non utilises, transitions manquantes
3. Prevoir etat par defaut: robustesse face aux erreurs
4. Documenter clairement: noms d'etats explicites
5. Simuler avant implementation: eviter erreurs couteuses
6. Respecter contraintes temporelles: setup/hold critiques

Pieges a eviter:

• Boucles combinatoires (feedback sans bascule)
• Aleas (glitches) sur signaux critiques
• Reset incomplet (etats non couverts)
• Violations setup/hold time
• Clock gating sans precaution

En conclusion, la logique sequentielle est au coeur de tout systeme numerique complexe. La maitrise des FSM et des techniques de conception synchrone est indispensable pour developper des controleurs fiables et performants, que ce soit en ASIC, FPGA ou microcontroleurs.

S R | Q  Q'
----|-------
0 0 | Q  Q'  (memory)
0 1 | 0  1   (reset)
1 0 | 1  0   (set)
1 1 | X  X   (forbidden)

J K | Q(t+1)
----|--------
0 0 | Q      (memory)
0 1 | 0      (reset)
1 0 | 1      (set)
1 1 | Q'     (toggle)

S0 (init, out=0) --[1]--> S1 (out=0)
S1 --[0]--> S2 (out=0)
S2 --[1]--> S3 (out=1)  // Sequence detected!
S3 --[x]--> ...

Current State | Timer | Next State   | Outputs
--------------|-------|--------------|----------
GREEN         | 0     | GREEN        | G=1,Y=0,R=0
GREEN         | 1     | YELLOW       | G=1,Y=0,R=0
YELLOW        | 0     | YELLOW       | G=0,Y=1,R=0
YELLOW        | 1     | RED          | G=0,Y=1,R=0
RED           | 0     | RED          | G=0,Y=0,R=1
RED           | 1     | GREEN        | G=0,Y=0,R=1

State | Binary | One-Hot | Gray
------|--------|---------|------
S0    | 00     | 0001    | 00
S1    | 01     | 0010    | 01
S2    | 10     | 0100    | 11
S3    | 11     | 1000    | 10

if (reset = '1') then
    state <= S0;
elsif rising_edge(clk) then
    state <= next_state;
end if;

if rising_edge(clk) then
    if (reset = '1') then
        state <= S0;
    else
        state <= next_state;
    end if;
end if;

UP:   000 -> 001 -> 010 -> 011 -> 100 -> 101 -> 110 -> 111 -> 000
DOWN: 111 -> 110 -> 101 -> 100 -> 011 -> 010 -> 001 -> 000 -> 111

Asynchronous input -> [FF1] -> [FF2] -> Synchronous output
                        CLK      CLK

FF1 --[tpd=2ns]--> NAND --[tpd=3ns]--> XOR --[tpd=4ns]--> FF2
                                                          [tsu=1ns]

State | Input 0  | Input 1  | Output
------|----------|----------|--------
S0    | S0       | S1       | 0
S1    | S2       | S1       | 0
S2    | S0       | S3       | 0
S3    | S0       | S4       | 0
S4    | S0       | S1       | 1

process(clk, reset)
begin
    if reset = '1' then
        state <= S0;
    elsif rising_edge(clk) then
        case state is
            when S0 =>
                if input = '1' then
                    state <= S1;
                end if;
            when S1 =>
                -- transitions...
        end case;
    end if;
end process;

-- Moore output logic
output <= '1' when state = S3 else '0';

always @(posedge clk or posedge reset) begin
    if (reset)
        state <= S0;
    else
        state <= next_state;
end

// Next_state and output logic (combinational)
always @(*) begin
    case (state)
        S0: begin
            if (input)
                next_state = S1;
            output = 1'b0;
        end
        // ...
    endcase
end