Transcript Document 7160524

Initiation
à la logique programmable
Initiation à la logique programmable - D.Genet - Janvier 2006
1
Typologie des circuits logiques
Un système électronique numérique pourra être implémenté avec des
circuits logiques de divers types :
standards
configurables
1 fonction
par circuit
PAL, CPLD
FPGA
à mémoire
RAM, ROM
séquentiables
Microprocesseurs
Microcontrôleurs
DSP
spécialisés
Mixtes :
FPGA + MICRO + RAM
Périphériques
standards,
ASICs
SOC (System On Chip)
Initiation à la logique programmable - D.Genet - Janvier 2006
2
Typologie des
circuits
logiques
Les composants programmables
à configuration interne
à configuration interne
figée
programmable
(microprocesseurs)
(PLDs, CPLDs, FPGA,...)
Langages de
programmation:
Assembleur,
langage haut niveau
(C, java...)
Séquence
d'instructions
Méthodes &
Outils de
conception
Langages de
description :
Abel, AHDL
langage haut niveau
(VHDL,Verilog)
Fichier de
configuration
Initiation à la logique programmable - D.Genet - Janvier 2006
3
Intérêt des PLDs
PLDs (Programmable Logic Devices) : acronyme générique
de tout ce qui est circuit logique programmable (SPLDs,
CPLDs, FPGA).
L’intérêt que présentent les circuits programmables par rapport
aux circuits à structure figée tient essentiellement à des impératifs
technico-économiques, résumés en quelques mots clés :
Intégration
Temps réel
Développement
Confidentialité
Initiation à la logique programmable - D.Genet - Janvier 2006
4
Intérêt des
PLDs
Intégration de systèmes par les PLDs
x10 portes
Moins de
boîtiers :
Moins de cartes
x100 portes
Cartes plus
petites
Consommation
réduite
1000 à 10000 portes 1000 à x1000 000 portes
Initiation à la logique programmable - D.Genet - Janvier 2006
5
Intérêt des
PLDs
Intégration fonctionnelle
Il est courant d’implémenter avec le même
circuit plusieurs fonctions distinctes
Contrôleur
I2C
Port série
Contrôleur
VGA
Contrôleur
caméra
Préprocesseur
pixels
Contrôleur
RAM
A la limite on crée un SOC : Système On Chip
Initiation à la logique programmable - D.Genet - Janvier 2006
6
Intérêt des
PLDs
Temps réel : parallélisme
Les unités fonctionnelles d’un PLD peuvent réagir
simultanément et sans délai au même signal
Unité
1
Unité
2
Unité
3
Initiation à la logique programmable - D.Genet - Janvier 2006
7
Intérêt des
PLDs
Temps réel : pipeline
Les unités fonctionnelles d’un PLD peuvent travailler
simultanément de façon concurrentes
Unité
1
Unité
2
Unité
3
Unité
4
Unité
5
Unité
6
Unité
7
Unité
8
Unité
9
Initiation à la logique programmable - D.Genet - Janvier 2006
8
Intérêt des
PLDs
Développement aisé
Existence d’outils de développement totalement
dédiés à la conception de systèmes sur PLDs.
Possibilité de portage de projets déjà implémentés
sur d’autres cibles.
Possibilité d’utiliser des noyaux de propriété
intellectuelle (IP)* pour des fonctions standards.
Le marché offre de plus en plus de PLDs intégrant
des fonctions complexes jusqu’alors implémentées
par des circuits spécialisés (RAM, multiplieurs…)
...
* ou libres…
Initiation à la logique programmable - D.Genet - Janvier 2006
9
Intérêt des
PLDs
Développement flexible
Un modification même majeure des spécifications
techniques n’entraîne pas nécessairement une
modification de l’environnement externe des PLDs
(circuit imprimé en particulier)
Les PLDs actuels sont reconfigurables
indéfiniment soit in situ soit par leur mémoire
(PROM ou FLASH) de configuration.
...
Initiation à la logique programmable - D.Genet - Janvier 2006
10
Intérêt des
PLDs
Coûts
Tous les arguments cités en faveur des PLDs ont une
incidence sur les côuts :
Intégration : réduction des coûts d ’industrialisation
(surface PCB, manipulations)
Développement : réduction des délais de
développement et de coût des avenants de
modifications
Portabilité des projets : les investissements
intellectuels sont récupérables pour d’autres
projets ou même commercialisables sous
forme d ’IP.
Initiation à la logique programmable - D.Genet - Janvier 2006
11
Intérêt des
PLDs
Confidentialité
Sauf recopie intégrale d’un système intégrant des PLDs
il est difficile d’en refaire la synthèse logique au seul
examen des circuits et de leur fonctionnement...
Les PLDs directement configurables disposent en général
de la possibilité d’être programmés sans possibilité de
relecture de leur configuration (bit de sécurité).
Initiation à la logique programmable - D.Genet - Janvier 2006
12
Intérêt des
PLDs
Microcontrôleur ou PLDs ?
La réalisation d’un système logique séquentiel peut amener
à faire un choix entre microcontrôleur et PLD.
D’où la nécessité d’en connaître quelques différences
fondamentales :
Un PLD est capable de réagir en temps
réel à un changement d’état de ses
entrées.
Un PLD est capable d’implémenter plusieurs
processus fonctionnant en parallèle
Un PLD offre beaucoup plus de ports E/S
qu’un microcontrôleur.
Initiation à la logique programmable - D.Genet - Janvier 2006
13
Intérêt des
PLDs
Limites des PLDs
Tout en présentant d’indéniables qualités, les PLDs
présentent également des limites :
Rapidité : les fréquences d ’horloge sont
limitées au mieux à quelques centaines de MHz
en raison des délais de propagation induits par
le routage.
Coût total
Coût : si le coût de
développement est en
général avantageux, le
coût en quantité peut
s’avérer plus lourd que
celui d’une solution à
base d’ASICs.
Initiation à la logique programmable - D.Genet - Janvier 2006
PLDs
Asics
Quantité
14
Les PLDS : Approche
Circuit programmable : circuit capable de
recevoir une configuration programmée
de ses ressources intégrées.
La majorité des circuits programmables du
marché sont des circuits logiques (peu
d’analogiques)
Principaux constructeurs du marché :
Actel
AMD
Vantis
Altera
Philips
Xilinx
DG France : ancien ESEO
DG France : ancien ESEO
Initiation à la logique programmable - D.Genet - Janvier 2006
15
Les PLDS : Un ancêtre, le FPLA (1982)
Entrées
*
* fusibles titanium-tungstène
82S100 (Signetics) : 16 entrées (e1..e16), 8 sorties (S1..S8),
48 termes produits (P1..P48).
48x16x2 + 48 x 8 = 1920 points de configuration
Initiation à la logique programmable - D.Genet - Janvier 2006
16
Un ancêtre :
le FPLA
FPLA : analyse de la configuration
Compte tenu des points de configuration activés
(ou plutôt coupés), par exemple :
Le terme produit P1 est issu
d’un ET câblé tel que :
+5V
e1
P1 = e1.e2.e3
La sortie S1 est issue
d’un OU câblé tel que :
S1 = P1 + P3
e2
P1
e3
+5V
P1
P2
P3
S1
Ici P3 = 0 ; il reste :
S1 = e1.e2.e3
Initiation à la logique programmable - D.Genet - Janvier 2006
17
Un ancêtre :
le FPLA
FPLA : représentation symbolique
Pour schématiser l’organisation et la configuration d’un
PLD, on utilise en général la représentation suivante :
e1
e2
e3
P1
P2
P3
S1
Initiation à la logique programmable - D.Genet - Janvier 2006
S2
18
Un ancêtre :
le FPLA
FPLA : synthèse
Au final, l’organisation d’un FPLA s’appuie sur
deux matrices programmables :
e1
e2
e3
Matrice
de OU
P1
P2
P3
Matrice de ET
S1
S2
La matrice de ET fournit n termes produits à la matrice de OU.
Initiation à la logique programmable - D.Genet - Janvier 2006
19
Les PLDS actuels : désignation
Les circuits logiques programmables du marché sont
classés en gros selon 3 grandes familles :
SPLDs (Simple Programmable Logic devices)
Les PLDS
actuels : désignation
CPLDs
(Complex Programmable Logic Devices)
FPGAs (Field Programmable Gates Array)
Les critères de cette classification seront présentés
lors de la synthèse finale de cet exposé.
Initiation à la logique programmable - D.Genet - Janvier 2006
20
Les SPLDs
Faible volume de ressource : quelques centaines
de portes
Pas de chemin d’interconnexion interne programmable
(pas de « routage » nécessaire entre les E/S
et les ressources du PLD)
Unique réseau programmable de ET commun à un
certain nombre de structures répétitives.
Exemples : PAL, GAL, EPLD
Initiation à la logique programmable - D.Genet - Janvier 2006
21
Les SPLDs
Un SPLD : le PAL
(Programmable Array Logic)
Exemple : PAL16L8
(représentation partielle)
Le réseau programmable est ici constitué d’une matrice de 32
colonnes x 64 lignes. Les colonnes donnent accès à toutes les
entrées (directes et inverses) .
Initiation à la logique programmable - D.Genet - Janvier 2006
22
Les SPLDs
PAL16L8 : la cellule
Les lignes sont regroupées
ici par 10 pour former un motif
répétitif, la cellule logique.
Chaque cellule peut ici :
Faire la somme de 7 termes produits
Configurer la borne I/O en entrée ou en sortie
Initiation à la logique programmable - D.Genet - Janvier 2006
23
Les SPLDs
PAL16L8 : l ’organisation
10 Entrées externes
Cellule logique
6 Entrées externes
ou rétroactions
(10 lignes)
Pin I/O
Buffer
3 états
Réseau programmable
8x10lignes /
32 colonnes
8 cellules logiques chevauchent un réseau de 32 colonnes
Initiation à la logique programmable - D.Genet - Janvier 2006
24
Les SPLDs
Exercice : Contrôleur d’interruption
I0
I1
I2
I3
I4
I5
I6
I7
/IRQ
Contrôleur
d ’IT
3
A[2:0]
Micro
processeur
Le rôle du contrôleur d ’interruption est triple :
Signaler au microprocesseur qu’une IT est demandée (/IRQ = 0)
Indiquer le numéro d’IT à servir (codée sur 3 bits A[2:0])
Gérer la priorité des demandes : IT0 aura la plus grande priorité
8 entrées 4 sorties : a priori un PAL16L8 fera l’affaire
Initiation à la logique programmable - D.Genet - Janvier 2006
25
Les SPLDs
Contrôleur d’IT : Table des états
I7 I6 I5 I4 I3 I2 I1 I0
S1
S2
S3
S4
S5
S6
S7
S8
S9
X
X
X
X
X
X
X
1
0
X
X
X
X
X
X
1
0
0
X
X
X
X
X
1
0
0
0
X
X
X
X
1
0
0
0
0
X
X
X
1
0
0
0
0
0
X
X
1
0
0
0
0
0
0
X
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
/IRQ A2 A1 A0
0
0
0
0
0
0
0
0
1
0
0
0
0
1
1
1
1
X
0
0
1
1
0
0
1
1
X
0
1
0
1
0
1
0
1
X
Chaque état du système est désigné par un label : S1 à S9.
Ces labels servent par la suite à établir les équations des
sorties sans utiliser directement les termes canoniques.
Initiation à la logique programmable - D.Genet - Janvier 2006
26
Les SPLDs
Contrôleur d’IT : Equations sources
Equations des états : (syntaxe ABEL ou AHDL)
S1
S2
S3
S4
S5
S6
S7
S8
S9
= I0;
= I1 &
= I2 &
= I3 &
= I4 &
= I5 &
= I6 &
= I7 &
=!I7 &
!I0;
!I1 &
!I2 &
!I3 &
!I4 &
!I5 &
!I6 &
!I6 &
!I0;
!I1 &
!I2 &
!I3 &
!I4 &
!I5 &
!I5 &
!I0;
!I1 &
!I2 &
!I3 &
!I4 &
!I4 &
Equations des sorties :
!IRQ = S9;
!A0 = S1 # S3 # S5 # S7;
!A1 = S1 # S2 # S5 # S6;
!A2 = S1 # S2 # S3 # S4;
!I0;
!I1 &
!I2 &
!I3 &
!I3 &
!I0;
!I1 & !I0;
!I2 & !I1 & !I0;
!I2 & !I1 & !I0;
Attention : les buffers du
PAL16L8 sont inverseurs.
Il faut alors exprimer les
inverses des sorties
désirées.
Initiation à la logique programmable - D.Genet - Janvier 2006
27
Contrôleur d’IT : configuration du PAL
Les SPLDs
I7
/IRQ
I6
A0
I5
A1
I4
A2
I7
I6
I5
I4
I3
I2
I1
I0
Initiation à la logique programmable - D.Genet - Janvier 2006
28
Les SPLDs
Exercice : décodeur d’adresse
Le PAL16L8 et ses dérivés conviennent à la réalisation de petites
fonctions combinatoires : multiplexeurs, décodeurs, encodeurs...
Exemple : on veut réaliser un décodeur d ’adresses pour 3 plages
définies sur 16 bits comme suit :
plage0 : ADR < 04000h
plage1 : 04000h <= ADR < 07C00h
plage2 : 07C00h >= ADR
En première approximation le décodeur se présentera comme suit :
CS0
A[15..0]
décodeur
CS1
CS2
Initiation à la logique programmable - D.Genet - Janvier 2006
29
Les SPLDs
Décodeur : analyse
En fait les 8 bits de poids faible de l’adresse n’interviennent pas
dans ce décodage. Une table de vérité permet d’affiner d’analyse.
0000->3fff
plage0
4000->6fff
plage1
7000->7bff
7c00->ffff
plage2
A15..A12 A11..A8
0000
0000
0011
0100
0110
0111
0111
0111
1111
CS0
CS1
CS2
0
1
1
1
0
1
1
0
1
1
1
0
1111
0000
1111
0000
1011
1100
1111
Les 6 bits de poids fort suffisent pour ce décodeur
Initiation à la logique programmable - D.Genet - Janvier 2006
30
Les SPLDs
Décodeur : équations sources
A[15..10]
décodeur
CS0
CS1
CS2
module DECODEUR *Décodeur décrit en langage ABEL (DATAIO)
declarations
DECODEUR device 'P16L8';
A15,A14,A13,A12,A11, A10 PIN 02,03,04,05,06,07;
CS0,CS1,CS2 PIN 19,18,17;
ADR =
[A15,A14,A13,A12,A11,A10,X,X,X,X,X,X,X,X,X,X];
equations
!CS0 = (ADR < ^h4000);
!CS1 = (ADR >= ^h4000) & (ADR < ^h7C00);
!CS2 = (ADR >= ^h7C00);
end DECODEUR;
Initiation à la logique programmable - D.Genet - Janvier 2006
31
Les SPLDs
Décodeur : équations réduites
La compilation du fichier source précédent donne les
équations réduites, c’est-à-dire ramenées en sommes
de termes canoniques utilisant les seuls signaux
nécessaires.
!CS0 =
!A15 & !A14;
!CS1 =
!A15
# !A15
# !A15
# !A15
&
&
&
&
A14
A14
A14
A14
&
&
&
&
!A10
!A11
!A12
!A13);
!CS2 =
A14 & A13 & A12 & A11 & A10
# A15;
Initiation à la logique programmable - D.Genet - Janvier 2006
32
Les SPLDs
Décodeur : fichier de configuration
L ’assemblage des équations réduites produit le fichier de configuration
(fichier fusibles) du réseau programmable de la cible désignée.
NOTE Table of pin names and numbers*
NOTE PINS A15:2 A14:3 A13:4 A12:5 A11:6 A10:7*
NOTE PINS CS0:19 CS1:18 CS2:17*
L0000 11111111111111111111111111111111*
L0032 10111011111111111111111111111111*
L0256 11111111111111111111111111111111*
L0288 10110111111111111111101111111111*
L0320 10110111111111111011111111111111*
L0352 10110111111110111111111111111111*
L0384 10110111101111111111111111111111*
L0512 11111111111111111111111111111111*
L0544 11110111011101110111011111111111*
L0576 01111111111111111111111111111111*
Ce fichier ne désigne que les lignes de la matrice intervenant dans
le projet : les ‘ 1 ’ correspondent aux fusibles à couper.
Initiation à la logique programmable - D.Genet - Janvier 2006
33
Les SPLDs
Décodeur : programmation du PAL
Un programmateur spécialisé fait fondre les fusibles du PAL selon les
directives du fichiers de fusibles ( = fusible intact).
A15
CS0
A14
CS1
A13
CS2
A15 A14 A13 A12 A11 A10
Initiation à la logique programmable - D.Genet - Janvier 2006
34
Les SPLDs
Programmation d ’un SPLD : synthèse
Cahier des charges
Analyse du problème
Résolution du problème
par mise en équations ou algorithmes
Choix du PLD en fonction
du nombre d ’E/S
Saisie des équations ou algorithme
Compilation -> équations réduites
Génération d’un fichier de configuration
Initiation à la logique programmable - D.Genet - Janvier 2006
35
Les SPLDs
Un PAL pour le séquentiel : PAL16R8
R comme Register
clock
OE
Le réseau programmable est
identique à celui du PAL16L8.
L’architecture finale de la cellule
intègre une bascule D, dont l’horloge
est commune à toutes les cellules.
Initiation à la logique programmable - D.Genet - Janvier 2006
36
Les SPLDs
Un PAL plus flexible : PALCE16V8
Les PALs présentés en introduction aux SPLDs à titre d ’exemple ne sont
pratiquement plus disponibles. Ils sont remplacés par un PAL plus flexible,
plus performant, le PALCE16V8 (CE : CMOS Erasable ; V : versatile)
Réseau identique à celui
des PAL16L8 et PAL16R8
Initiation à la logique programmable - D.Genet - Janvier 2006
37
Les SPLDs
PALCE16V8 : la cellule
Les 8 cellules logiques de ce PAL sont configurables en :
- sortie combinatoire
- sortie séquentielle(registred)
- en entrée
grâce à 4 multiplexeurs programmables.
Initiation à la logique programmable - D.Genet - Janvier 2006
38
Les SPLDs
PALCE16V8 : le XOR programmable
La sortie traverse un XOR programmable.
Ce dispositif permet d’inverser la somme
fournie par le OU pour faire face aux cas
où le nombre de termes produits en entrée
serait supérieur à 8, ceci en utilisant les
propriétés du théorème de Morgan.
Ce système se retrouve pratiquement dans
toutes les cellules des PLDs.
Initiation à la logique programmable - D.Genet - Janvier 2006
39
Les SPLDs
Rôle du XOR programmable
Exemple : soit l ’équation réduite :
E8 =
#
#
#
#
#
#
#
#
#
!init
!init
!init
!init
!init
!init
!init
!init
!init
!init
&pbd &!x &!y
&pbc & x & y
&pba & x &!y
&pba &!x & y
&pbd &!x &!y
&pbc & x & y
&pba & x &!y
&pba &!x & y
&pbd &!x &!y
&test & E7 ;
&!test
&!test
&!test
&!test
& X7
& E7
& E7
& E7
& E7
&
&
&
&
E8
E8
E8
E8
Une seule cellule logique d’un PALCE16V8 sera incapable
d’implémenter directement cette somme : il y a 9 termes produits
et le OU de la cellule ne comporte que 8 entrées.
Initiation à la logique programmable - D.Genet - Janvier 2006
40
Les SPLDs
Rôle du XOR programmable (2)
Solution au problème : si le même terme E8 est exprimé par son
inverse, le résultat ne comportera plus ici que 7 termes produits :
!E8 = init
# !pbd
# !pbc
# !pba
# !pba
# !E7
# !E7
&!x &!y
& x & y
& x &!y
&!x & y
&!E8
&!test;
&!test
&!test
&!test
&!test
Le OU d’une cellule peut implémenter cette somme et le résultat
doit par la suite être inversé grâce au XOR programmable.
Cette opération d ’inversion est en général laissée au compilateur
qui choisit l’expression directe ou inversée de la somme selon les
cas, quand c’est possible.
Initiation à la logique programmable - D.Genet - Janvier 2006
41
Les SPLDs
Saturation de la cellule : problème
La saturation d’une cellule par excès de termes produits de la
somme à implémenter, non résolue par l’inversion, est un
problème récurrent.
La solution consiste en général à décomposer la somme autant
d’expressions que nécessaire pour permettre leur implémentation
chacun par une cellule distincte.
Initiation à la logique programmable - D.Genet - Janvier 2006
42
Les SPLDs
Saturation de la cellule : exemple
abcde
cellule1
/aux
/Y
cellule2
/Y
!Y= P1 # P2 # P3 # P4 # P5 # P6 # P7 # P8 # P9 # P10;
!aux = P1 # P2 # P3 # P4 # P5 #P6 # P7 # P8;
!Y = aux # P9# P10;
Initiation à la logique programmable - D.Genet - Janvier 2006
43
Les SPLDs
Message d’inadéquation
(1)
En général ce message correspond à une
combinatoire trop importante, représentée par
des équations réduites comportant trop de
termes produits.
Initiation à la logique programmable - D.Genet - Janvier 2006
44
Les SPLDs
Message d’inadéquation
(2)
Le projet demande plus de cellules logiques
que la cible choisie n’en possède.
Initiation à la logique programmable - D.Genet - Janvier 2006
45
Les SPLDs
Une variante aux PALs : le GAL
Generic Array Logic
Autre solution au problème précédent : utiliser des circuits dont les cellules
logiques comportent des OU possédant un nombre supérieur d’entrées, tel
le GAL22V10 de VANTIS (représentation partielle à 50%).
Réseau 130 x 44
Initiation à la logique programmable - D.Genet - Janvier 2006
46
Les SPLDs
GAL22V10 : la cellule
La cellule logique donne à quelques détails près les mêmes
possibilités de configuration qu’un PALCE grâce à
2 multiplexeurs programmables.
8 à 16 entrées
Initiation à la logique programmable - D.Genet - Janvier 2006
47
Les SPLDs
Exercice : bascule toggle
D
Clk
Q
Q
T
CS
Configurer la matrice de cette
cellule pour avoir une bascule
T (‘toggle’) avec clear synchrone
Initiation à la logique programmable - D.Genet - Janvier 2006
48
Les CPLDs
Volume moyen de ressources : quelques
milliers de portes.
Cellules logiques organisées en plusieurs
blocs logiques identiques ayant chacun leur
réseau programmable indépendant et non
relié directement aux pins E/S.
Chaque bloc logique est équivalent à un
SPLD sans pins.
Initiation à la logique programmable - D.Genet - Janvier 2006
49
Les CPLDs
Les CPLDs (2)
Chemin d’interconnexion interne programmable
par une matrice d’interconnexion commune.
(« routage » nécessaire entre les E/S et les
blocs du CPLD)
Pour une même puce, choix du boîtier en
fonction des pins E/S nécessaires.
Exemple : famille EPM7000 de Altera
Initiation à la logique programmable - D.Genet - Janvier 2006
50
Les CPLDs
Famille EPM7000 (Altera) : organisation
LAB : logic Array Block
PIA : Programmable
Interconnection Array
Initiation à la logique programmable - D.Genet - Janvier 2006
51
Les CPLDs
Famille EPM7000 (Altera) : la cellule
En plus d’une structure finale classique, la cellule possède accède à un
réseau local (16 colonnes) et possède deux dispositifs permettant
l’implémentation des grosses équations combinatoires, les expanders.
Initiation à la logique programmable - D.Genet - Janvier 2006
52
Les CPLDs
Famille EPM7000 (Altera) : les expanders
Expansion partagée par le bloc logique
Une ligne par cellule peut servir à fournir une colonne
supplémentaire au réseau local du bloc logique concerné.
Initiation à la logique programmable - D.Genet - Janvier 2006
53
Les CPLDs
Famille EPM7000 (Altera) : les expanders
(2)
Expansion parallèle
Chaque cellule peut fournir un terme supplémentaire au OU de
la cellule voisine.
Initiation à la logique programmable - D.Genet - Janvier 2006
54
Les CPLDs
Famille EPM7000S (Altera) : les blocs E/S
I/O Block
Compatible
5Vet 3.3V
(dépendant de
VCCINT et VCCIO)
Les buffers de sorties sont à triple contrôle.
Initiation à la logique programmable - D.Genet - Janvier 2006
55
Les CPLDs
Famille EPM7000 (Altera) : les puces
EPM7xxxS : programmable in situ
Initiation à la logique programmable - D.Genet - Janvier 2006
56
Les CPLDs
Famille EPM7000 (Altera) : rapidité
-5 correspond à un temps de propagation tpd = 5ns
Initiation à la logique programmable - D.Genet - Janvier 2006
57
Les CPLDs
Famille EPM7000 (Altera) : les boîtiers
Initiation à la logique programmable - D.Genet - Janvier 2006
58
Les FPGAs
(Field Programmable Gate Array)
Volume élevé de ressources : de quelques
milliers à à quelques millions de portes
Cellules logiques de petite taille, jusqu’à
plusieurs dizaines de milliers.
(pas de réseau logique programmable)
Cellules organisées en une unique matrice
Ou en matrice de petits blocs de cellules
(LAB : logic arrays blocks)
Initiation à la logique programmable - D.Genet - Janvier 2006
59
Les FPGAs
Les FPGAs
(2)
Combinatoire implémentable par des
L.U.T. (Look Up Table) = mémoire
LUT
donnée
n
adresse
Entrées
1
Sortie
Lignes et colonnes d’interconnexion
programmables entre les cellules et les
blocs E/S
Initiation à la logique programmable - D.Genet - Janvier 2006
60
Les FPGAs
Les FPGAs
(3)
(Field Programmable Gate Array)
Ressources RAM embarquées
Sur certaines familles :
- Multiplieurs câblés
- noyau microprocesseur
Configuration interne par une SRAM
Contrairement aux CPLDs et SPLDs dont la
configuration est basée sur une EEPROM,
celle d’un FPGA est VOLATILE.
Initiation à la logique programmable - D.Genet - Janvier 2006
61
Les FPGAs
FPGAs : structure générale
Cellule logique
Blocs E/S
Lignes
d’interconnexions
NB :La matrice va de 10x10 à 100x100 et plus !
Initiation à la logique programmable - D.Genet - Janvier 2006
62
Les FPGAs
FPGAs : structure détaillée
Initiation à la logique programmable - D.Genet - Janvier 2006
63
Les FPGAs
FPGAs : RAM embarquée
Position
centrale:
minimisation
desTpd
Initiation à la logique programmable - D.Genet - Janvier 2006
64
Les FPGAs
FPGAs : structure fonctionnelle
Un FPGA possède en fait 3 couches structurelles :
SRAM de
configuration
Interconnexions
configurables
Ressources
(Cellules, RAM)
Chaque bit de la SRAM est vu soit par un nœud des interconnexions,
soit par un multiplexeur ou une LUT des ressources.
Initiation à la logique programmable - D.Genet - Janvier 2006
65
Les FPGAs
FPGA Exemple 1 : XC4000 (Xilinx)
Portes : de 1600 à 85000
Cellules : de 64 (8x8) à 3136 (56x56)
RAM : de 2 kbits à 100 kbits
Fréquence système : jusqu’à 80 MHz
Initiation à la logique programmable - D.Genet - Janvier 2006
66
Les FPGAs
XC4000 : la cellule
CLB : Configurable Logic Block
(version combinatoire : 3 générateurs de fonctions F,G,H)
Initiation à la logique programmable - D.Genet - Janvier 2006
67
Les FPGAs
XC4000 : la mémoire répartie
(version mémoire : organisation 16x2 bits)
Initiation à la logique programmable - D.Genet - Janvier 2006
68
Les FPGAs
XC4000 : les interconnexions
PSM : Programmable Switches Matrice
Initiation à la logique programmable - D.Genet - Janvier 2006
69
Les FPGAs
XC4000 : les interconnexions, détail
Initiation à la logique programmable - D.Genet - Janvier 2006
70
Les FPGAs
XC4000 : Bloc E/S
Initiation à la logique programmable - D.Genet - Janvier 2006
71
Les FPGAs
XC4000 : exemple de routage
Initiation à la logique programmable - D.Genet - Janvier 2006
72
Les FPGAs
XC4000 : la famille
* 20 à 30 % de la RAM est utilisée dans un projet.
Initiation à la logique programmable - D.Genet - Janvier 2006
73
Les FPGAs
FPGA Exemple 2 : ACEX (Altera)
Initiation à la logique programmable - D.Genet - Janvier 2006
74
Les FPGAs
FPGA Exemple 2 : ACEX (Altera)
Initiation à la logique programmable - D.Genet - Janvier 2006
75
Les FPGAs
FPGA Exemple 2 : ACEX (Altera)
Initiation à la logique programmable - D.Genet - Janvier 2006
76
Les FPGAs
FPGA Exemple 2 : ACEX (Altera)
3 à 12 EAB (Embedded Array Block)
1 EAB 12 288 bits
Initiation à la logique programmable - D.Genet - Janvier 2006
77
Les FPGAs
FPGA Exemple 3 : Virtex 2 pro (Xilinx)
Initiation à la logique programmable - D.Genet - Janvier 2006
78
Les FPGAs
Virtex 2 pro :
organisation
générale
Initiation à la logique programmable - D.Genet - Janvier 2006
79
Les FPGAs
Virtex 2 pro : la cellule logique
Initiation à la logique programmable - D.Genet - Janvier 2006
80
Les FPGAs
Virtex 2 pro : les
slices
Initiation à la logique programmable - D.Genet - Janvier 2006
81
Les FPGAs
Virtex 2 pro : détail
du slice
Initiation à la logique programmable - D.Genet - Janvier 2006
82
CPLD
vs
FPFGA
CPLD ou FPGA ?
CPLD et FPGA, pareil ?
NON ! Tous les deux sont des circuits logiques
programmables, fabriqués par les mêmes constructeurs.
Mais ils sont différents :
Les FPGAs ont des cellules logiques de petite
taille avec une ou deux bascules et en possèdent
plusieurs milliers.
Les CPLDs ont des cellules logiques de grande
taille avec une bascule et n’en possèdent que
quelques centaines.
Initiation à la logique programmable - D.Genet - Janvier 2006
83
CPLD
vs
FPFGA
CPLD ou FPGA : configuration
La configuration des FPGAs est basée sur une
SRAM, qui a besoin d’être rechargée à chaque
mise sous tension.
La configuration des CPLDs est basée sur une
EEPROM, dont le contenu enregistré depuis
la dernière configuration persiste indéfiniment.
Initiation à la logique programmable - D.Genet - Janvier 2006
84
CPLD
vs
FPFGA
CPLD ou FPGA : routage
Les FPGAs contiennent de larges ressources
d’interconnexions entre les cellules logiques
et les blocs d ’entrées sorties.
La capacité de routage des CPLDs est limitée
à peu de choses, rendant vite difficile l’intégration
de projets complexes.
Initiation à la logique programmable - D.Genet - Janvier 2006
85
CPLD
vs
FPFGA
CPLD ou FPGA : rapidité
À fonction logique égale un CPLD pourra être plus
rapide qu’un FPGA car sa capacité à réaliser une
logique combinatoire en un seul étage est
meilleure que celle d’un FPGA.
Une cellule logique de CPLD peut intégrer une grosse
équation logique grâce à son réseau programmable,
ce que possèdent pas les cellules de FPGA.
Initiation à la logique programmable - D.Genet - Janvier 2006
86
CPLD
vs
FPFGA
CPLD ou FPGA : taille projet
Petit projet
Gros projet
:
SPLD ou CPLD
:
FPGA
Initiation à la logique programmable - D.Genet - Janvier 2006
87
CPLD
vs
FPFGA
Synthèse : les SPLDs et sCPLD
entrées rétroactions
Cellule
I/O
Pins reliées au réseau
et aux cellules
SPLD
Pins et cellules à relier
via des réseaux programmables
d’interconnexion
Réseau
de ET
Cellules associées à
un réseau commun de ET
CPLD
Configuration
non volatile
Initiation à la logique programmable - D.Genet - Janvier 2006
88
CPLD
vs
FPFGA
Synthèse : les SPLDs et sCPLD
Nombreuses
petites cellules
organisées
matriciellement
sans réseau de ET
FPGA
Configuration
sur SRAM
volatile
Initiation à la logique programmable - D.Genet - Janvier 2006
89
Modes de programmation des PLDs
Une fois le fichier de configuration disponible, la
programmation du PLD peut correspondre à plusieurs
cas de figure :
SPLDs (pal, gal) :
sur programmateur
CPLDs :
sur programmateur ou in situ
FPGA :
in situ (SRAM ou FLASH)
Initiation à la logique programmable - D.Genet - Janvier 2006
90
Programmation
des
PLDs
SPLD DIP sur programmateur
Initiation à la logique programmable - D.Genet - Janvier 2006
91
Programmation
des
PLDs
SPLD CMS sur programmateur
Initiation à la logique programmable - D.Genet - Janvier 2006
92
Programmation
des
PLDs
Programmation des CPLDs
Utilisation d’un programmateur
Démarche pratiquement obsolète
In Situ (Boîtiers ISP : In System Programmable)
Le circuit possède alors un interface approprié.
L’interface le plus connu est celui du JTAG
avec ses 4 signaux : TCK, TMS, TDI et TDO.
Cet interface permet d’écrire (et de lire)
directement l’EEPROM de configuration
interne du CPLD.
Initiation à la logique programmable - D.Genet - Janvier 2006
93
Programmation
des
PLDs
Programmation in situ
(ISP)
Nécessité de prévoir sur le PCB le connecteur destiné
au câble de configuration.
Initiation à la logique programmable - D.Genet - Janvier 2006
94
Programmation
des
PLDs
Principe de la programmation EPROM
Principe du point de contact programmable :
transistor N-MOS à grille « flottante » à injection de
charge.
Initiation à la logique programmable - D.Genet - Janvier 2006
95
Programmation
des
PLDs
Cellule EPROM : structure
Largeur du canal :
finesse de la gravure (<1µ)
Par défaut, cette structure est conductrice : la résistance
entre drain et source du transistor N-MOS est faible.
La programmation consistera à rendre non conducteurs
(mise « off ») les points appropriés du PLD.
Initiation à la logique programmable - D.Genet - Janvier 2006
96
Programmation
des
PLDs
Cellule EPROM : mise « off »
En portant la grille à un potentiel suffisamment élevé, le
champ créé « aspire » des électrons qui se font piéger
dans la grille flottante.
Initiation à la logique programmable - D.Genet - Janvier 2006
97
Programmation
des
PLDs
Cellule EPROM : effacement
Vg = 0
Vss >0
Il suffit par exemple d’inverser le potentiel Vgs pour
« vider » la grille flottante de ses électrons.
Initiation à la logique programmable - D.Genet - Janvier 2006
98
Programmation
des
PLDs
Programmation des FPGA
In Situ
La SRAM interne du FPGA est écrite (ou lue)
via l’interface JTAG du circuit.
Intérêt : opération relativement rapide
Inconvénient : configuration volatile.
Initiation à la logique programmable - D.Genet - Janvier 2006
99
Programmation
des
PLDs
Programmation des FPGAs
Par PROM ou EEPROM de configuration série
La SRAM interne du FPGA reçoit à la mise
sous tension le contenu d’une mémoire ROM
externe via un interface spécialisé (qui peut
être distinct du JTAG).
Intérêt : opération très rapide et automatique
à chaque mise sous tension.
Inconvénient : configuration de la PROM lente.
Initiation à la logique programmable - D.Genet - Janvier 2006
100
Programmation
des
PLDs
Exemple matériel : photo 1
Câble de
configuration
Initiation à la logique programmable - D.Genet - Janvier 2006
101
Programmation
des
PLDs
Exemple matériel : photo 2
Oscillateur
à quartz
JTAG
2.5V
SSRAM
3.3V
FPGA
EEPROM
Initiation à la logique programmable - D.Genet - Janvier 2006
102
Programmation
des
PLDs
Exemple matériel : photo 3
Boîtier PQFP
Initiation à la logique programmable - D.Genet - Janvier 2006
103
Programmation
des
PLDs
Exemple matériel : photo 4
Boîtier TQFP
DIP switch
Boîtier PLCC
Initiation à la logique programmable - D.Genet - Janvier 2006
104
Programmation
des
PLDs
Schéma d’un système de configuration
Les deux dispositifs
peuvent être combinés
EEPROM de
configuration
Choix du
mode
Initiation à la logique programmable - D.Genet - Janvier 2006
Connecteur
JTAG de
configuration
105
Alimentations des FPGAs
La plupart des FPGAS actuels nécessitent plusieurs alimentations :
VCCINT
de 1,2 V à 2,5 V. Alimente le noyau du FPGA,
VCCIO
de 3,3 V à 5 V. Alimente les cellules d’entrées sorties.
Initiation à la logique programmable - D.Genet - Janvier 2006
106
Représentation d’un
système logique
… ou comment représenter une système
autrement que par un schéma, en faisant une
description textuelle.
Initiation à la logique programmable - D.Genet - Janvier 2006
107
Système logique : définitions
e
m
e
2
e
1
s
p
SYTEME
LOGIQUE
s
2
s
1
E = { e1, e2, ... , em } est l'alphabet d'entrée du système
S = { s1, s2, ... , sp } est l'alphabet de sortie du système
Si S(t) = f [E(t)] quelque soit t,
le système logique est un circuit combinatoire
Si S(t) = f[E(t), M(t)]
le système est alors un circuit séquentiel
Initiation à la logique programmable - D.Genet - Janvier 2006
108
Implémentation
d’un
système
séquentiel
Implémentation d’un système séquentiel
Etat futur
E
Etat présent
Q*
G
M
Q
F
S
Entrées
Variables Commande Variables internes
(Variables primaires) d'excitation écriture
(ou secondaires)
S(t) = f[E(t), M(t)]
M(t) représente l ’état du système à l ’instant t, mémorisé
par le bloc mémoire M à n bits, capable de représenter
2n états différents.
G et F sont des circuits combinatoires.
Initiation à la logique programmable - D.Genet - Janvier 2006
109
Implémentation
d’un
système
séquentiel
Système séquentiel : fonctionnement
Etat futur
E
G
Q*
Etat présent
M
Q
F
S
Commande d’écriture
Sur commande d’écriture la mémoire M prend l’état
Q* présent à son entrée. Cet état est fonction à la fois des
variables externes (E) et de l’état Q précédant le front.
Les sorties (S) sont fonctions de l’état Q de la mémoire
et éventuellement des variables externes (E).
Initiation à la logique programmable - D.Genet - Janvier 2006
110
Implémentation
d’un
système
séquentiel
Système séquentiel : horloge
Etat présent
Etat futur
Q*
M
Q
Horloge
La commande d’écriture est
généralement le front (montant
ou descendant) d’un signal
périodique appelé horloge.
Horloge
Q*
data1
data2
data3
data4
data5
Q
data0
data1
data2
data3
data4
Les changements d’état du bloc M sont dits synchrones de l’horloge.
Initiation à la logique programmable - D.Genet - Janvier 2006
111
Implémentation
d’un
système
séquentiel
Modèles : Moore ou Mealy
Etat futur
E
Etat présent
Q*
G
M
Horloge
Q
F
S
Lorsque les sorties (S) sont uniquement fonctions de l’état
(Q) du système, cette structure implémente une machine
d’état dite de Moore.
Si les entrées (E) interviennent également dans l’état des
sorties (S) (liaison pointillée), cette structure correspond
au modèle de Mealy.
Cette dernière construction est à déconseiller car les
changements d’état des sorties risquent de ne plus être
synchrones.
Initiation à la logique programmable - D.Genet - Janvier 2006
112
Implémentation
d’un
système
séquentiel
Cellule logique : système élémentaire 1 bit
Horloge
Fonction combinatoire
D
Strap ou
inverseur
Bloc G
Bloc M
Bloc F
Une cellule logique d’un PLD se prête parfaitement à
l’implémentation d’une machine d’état de Moore de 1 bit.
Initiation à la logique programmable - D.Genet - Janvier 2006
113
Implémentation
d’un
système
séquentiel
Implémentation d’un système n bits
Bloc G
Réseau
du PLD
Horloge
Bloc M
Bloc F
combinatoire 1
combinatoire 2
D
Q1
D
Q2
combinatoire n
D
Qn
L’association de n cellules logiques permet
l’implémentation d’une machine d ’état n bits, capable
de produire jusqu’à 2n états distincts.
Cette construction est idéale pour construire des compteurs
synchrones ou des séquenceurs synchrones spécifiques.
Initiation à la logique programmable - D.Genet - Janvier 2006
114
Implémentation
d’un
système
séquentiel
Système n bits et combinatoire
Dans le système précédent, le bloc F est réduit à sa plus
simple expression : les sorties sont directement les bits mémoire.
Réseau
du PLD
Bloc G
Horloge
Bloc M
combinatoire 1
combinatoire 2
D
combinatoire n
D
D
combinatoire F1
S1
S2
Bloc F
combinatoire F2
Cet exemple de système n bits possède 2 sorties, chacune étant
fonction combinatoire des états du bloc M grâce aux 2 cellules qui
implémentent le bloc F par les fonctions combinatoires F1 et F2
Initiation à la logique programmable - D.Genet - Janvier 2006
115
Exercice : compteur synchrone 4 bits
Méthode basique utilisant des bascules D :
Etablir la table des états successifs désirés, avec
un label pour chaque état (S1,S2, .. S15)
Etablir la table des entrées D nécessaires pour
obtenir les états suivants
En déduire les expressions logiques des entrées
D des bascules utilisées en fonctions des états
du système.
Cette méthode est universelle
et s’applique à tous les systèmes séquentiels.
On la désigne par méthode des tables des transitions
Initiation à la logique programmable - D.Genet - Janvier 2006
116
Exercice:
compteur
synchrone
4 bits
Compteur 4 bits : séquence d’états
Q3 Q2 Q1 Q0
S0
S1
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
S12
S13
S14
S15
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
Cette table présente la succession
désirée des états du compteur et
donne la correspondance avec
les labels attribués.
Le passage d’un état au suivant
sera provoqué par le front
considéré actif de l’horloge.
Initiation à la logique programmable - D.Genet - Janvier 2006
117
Exercice:
compteur
synchrone
4 bits
Compteur 4 bits : tables des transitions
État présent
S0
S1
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
S12
S13
S14
S15
État futur
S1
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
S12
S13
S14
S15
S0
D3 D2 D1 D0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
Très simple ici : les
états Di correspondent
aux états futurs
désirés
Cette table permet d’établir les équations Di des bascules.
Initiation à la logique programmable - D.Genet - Janvier 2006
118
Exercice:
compteur
synchrone
4 bits
Compteur 4 bits : équations Di
D0 = S0 # S2 # S4 # S6 # S8 # S10 # S12 # S14
D1 = S1 # S2 # S5 # S6 # S9 # S10 # S13 # S14
D2 = S3 # S4 # S5 # S6 # S11 # S12 # S13 # S14
D3 = S7 # S8 # S9 # S10 # S11 # S12 # S13 # S14
En exprimant les états en fonction des bits Qi et en réduisant
un peu le résultat on aurait obtenu les équations suivantes :
D0
D1
D2
D3
=
=
=
=
!Q0;
Q1 $ Q0;
Q2 $ (Q1 & Q0);
Q3 $ (Q2 & Q1 & Q0);
Initiation à la logique programmable - D.Genet - Janvier 2006
119
Exercice:
compteur
synchrone
4 bits
Compteur 4 bits : validation
On ajoute une validation par un signal VALID.
Chaque équation comprendra un terme d’activation conditionné
par VALID et un terme de maintien conditionné par !VALID
Terme d’activation
D0 = (S0 # S2 # S4 # S6
# Q0 & !VALID
# S8 # S10 # S12 # S14 )&
VALID
Terme de maintien
D1 = (S1 # S2 # S5 # S6
# Q1 & !VALID
# S9 # S10 # S13 # S14 )&
D2 = (S3 # S4 # S5 # S6
# Q2 & !VALID
# S11 # S12 # S13 # S14)&
D3 = (S7 # S8 # S9 # S10
# Q3 & !VALID
VALID
# S11 # S12 # S13 # S14 )&
Initiation à la logique programmable - D.Genet - Janvier 2006
VALID
VALID
120
Exercice:
compteur
synchrone
4 bits
Activation et maintien conditionnés
maintien
rétroaction
VALID
D
Q
Excitation E
CLK
activation
Horloge
D = (E & VALID) # (Q & !VALID);
activation
maintien
Initiation à la logique programmable - D.Genet - Janvier 2006
121
Exercice:
compteur
synchrone
4 bits
Compteur synchrone : initialisation
On ajoute une initialisation à zéro par un signal RAZ.
Chaque équation ainsi obtenue sera conditionnée par !RAZ
D0 = ((S0 # S2 # S4 # S6 # S8 #
# Q0 & !VALID)&!RAZ;
S10 # S12 # S14 )&
VALID
D1 = ((S1 # S2 # S5 # S6 # S9 #
# Q1 & !VALID )&!RAZ;
S10 # S13 # S14 )&
VALID
D2 = ((S3 # S4 # S5 # S6 # S11 #
# Q2 & !VALID )&!RAZ;
D3 = ((S7 # S8 # S9 # S10 # S11
# Q3 & !VALID )&!RAZ;
S12 # S13 # S14)&
# S12 # S13 # S14 )&
VALID
VALID
Cette initialisation sera du type SYNCHRONE
Initiation à la logique programmable - D.Genet - Janvier 2006
122
Exercice:
compteur
synchrone
4 bits
Remise à zéro synchrone
rétroaction
VALID
D
Q
Excitation E
CLK
RAZ
Horloge
D =((E & VALID)#(Q & !VALID))&!RAZ;
Initiation à la logique programmable - D.Genet - Janvier 2006
123
Exercice:
compteur
synchrone
4 bits
Compteur synchrone : modulo
On ajoute un modulo 10 programmable par le signal DIX.
Il faut examiner
l’incidence de ce modulo
sur la tables de
transitions : si DIX est
vrai, le compteur passe
de S9 à S0, sinon il
continue normalement.
On peut constater que
seuls
les bits D3 et D1 sont
concernés par cette
modification, ceci quand
le compteur est à l ’état
S9.
état
présent
S0
S1
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
S12
S13
S14
S15
état
futur
S1
S2
S3
S4
S5
S6
S7
S8
S9
S10
S0
S11
S12
S13
S14
S15
S0
D3 D2 D1 D0
0
0
0
0
0
0
0
1
1
0
1
1
1
1
1
1
0
Initiation à la logique programmable - D.Genet - Janvier 2006
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
124
Exercice:
compteur
synchrone
4 bits
Compteur modulo 10 : équations
Les équations de D3 et D1 sont modifiées de manière à
valoir 0 lorsque le compteur est à l’état S9.
Cela revient à conditionner S9 par le signal !DIX
D0 = ((S0 # S2 # S4 # S6 # S8 #
# Q0 & !VALID)&!RAZ;
D1 = ((S1
S10 # S12 # S14 )&
VALID
S9&!DIX
# S10 # S13 # S14)& VALID
# Q1 & !VALID )&!RAZ;
# S2 # S5 # S6 #
D2 = ((S3 # S4 # S5 # S6 # S11 #
# Q2 & !VALID )&!RAZ;
D3 = ((S7
# S8 #
S12 # S13 # S14)&
VALID
S9&!DIX
# S10 # S11 # S12 # S13 # S14)&
VALID
# Q3 & !VALID )&!RAZ;
Initiation à la logique programmable - D.Genet - Janvier 2006
125
Exercice:
compteur
synchrone
4 bits
Compteur : schéma structurel niveau PLD
RAZ
VALID
DIX
D0(RAZ,DIX,VALID,Q0,Q1,Q2,Q3)
d
D1(RAZ,DIX,VALID,Q0,Q1,Q2,Q3)
d
D2(RAZ,DIX,VALID,Q0,Q1,Q2,Q3)
d
D3(RAZ,DIX,VALID,Q0,Q1,Q2,Q3)
d
0
1
2
3
q
Q0
q
Q1
q
Q2
q
Q3
CLK
Il s‘agit là d’une structure a priori. Elle peut être augmentée de cellules
supplémentaires si la combinatoire ne peut absorber les équations.
Initiation à la logique programmable - D.Genet - Janvier 2006
126
Exercice : séquenceur spécifique
On désire concevoir un générateur synchrone de signal dont la sortie
délivrerait le signal périodique suivant :
Adopter d’abord un mode d’implémentation de ce
générateur en établissant un schéma structurel (bascules D
et combinatoire) et la table des transitions.
Etablir la table des entrées D nécessaires pour obtenir les
états voulus après le prochain front d ’horloge
Écrire les équations de pilotage des éléments
Essayer d’autres mode d’implémentation et déterminer pour chacun le
nombre de cellules logiques nécessaires.
Initiation à la logique programmable - D.Genet - Janvier 2006
127
Généralisation des tables de transition
Variables
externes
État
présent
État
futur
M
G
État
présent
Variables externes
État
futur
…….
La méthode des tables des transitions montre ici ses limites : sa taille peut
au pire doubler à chaque variable externe introduite !
Exercice : reprendre celui de la bascule toggle
Initiation à la logique programmable - D.Genet - Janvier 2006
128
Langages de description
La nécessité de pouvoir décrire un système logique sous
formes d’expressions compilables plus ou moins évoluées
a abouti à l’élaboration de langages de description textuelle :
Langages de très bas niveau : PALASM, ABEL
Non propriétaires, ils servent encore à programmer les SPLDs
Langages propriétaires : AHDL (Altera), MINC (Xilinx)
Destinés surtout aux CPLDs ou aux petites unités fonctionnelles
pour une description performante de niveau moyen.
Langages de très haut niveau : VHDL, VERILOG
Non propriétaires et normalisés, donc portables
Initiation à la logique programmable - D.Genet - Janvier 2006
129
Langages
de description
Structure générale d’une description
Les langages évolués, propriétaires ou non, présentent tous
une structure commune pour la description d’un système logique :
Description externe
C’est la vue externe du « composant », avec l’énumération des
signaux d’entrée / sortie et leurs dimensions, avec éventuellement
les numéros de broches de circuit auxquelles ils sont assignés.
Description interne
Organisée différemment selon les langages, cette section a pour
but d’énumérer de façon explicite ou implicite les ressources
internes du système et d’en décrire le comportement ou la structure.
Initiation à la logique programmable - D.Genet - Janvier 2006
130
Langages
de description
Exemple : Compteur CPT en AHDL
DIX
VALID
RAZ
CLOCK
CPT
4
COMPTEUR
Description externe en AHDL :
subdesign CPT(
CLOCK, RAZ, VALID, DIX : input;
COMPTEUR[3..0]: output;)
La sortie compteur est formée d’un groupe de 4 bits
dont COMPTEUR3 est le MSB et COMPTEUR0 le LSB.
Initiation à la logique programmable - D.Genet - Janvier 2006
131
Langages
de description
Exemple : Compteur en AHDL (2)
Description interne : ressources
...
variable
% déclaration de ressources : 4 bascules D (D Flip Flop)
compteur[3..0] : DFF;
Initiation à la logique programmable - D.Genet - Janvier 2006
132
Langages
de description
Exemple : Compteur en AHDL (3)
Description interne : équations logiques
...
begin % début de section logique
% entrées horloge
compteur[].clk = CLOCK;
% entrées d des bascules
compteur[].d =((
(compteur[]+1)
& !((compteur[]==9)& DIX)
)& VALID
#(compteur[] & !VALID)
)& !RAZ ;
end; % fin de section logique
Initiation à la logique programmable - D.Genet - Janvier 2006
133
Langages
de description
Primitive DFF de AHDL
La déclaration compteur[3..0] : DFF; signifie qu’à
chacun des 4 signaux groupés compteur3, compteur2,
compteur1, compteur0 se trouve associée une structure
(ou primitive) de type DFF (D Flip Flop).
Les éléments de cette structure portent des labels clés.
compteur0.prn
compteur0.d
d
prn
q
compteur0.q
compteur0
compteur0.clk
clk clrn
compteur0.clrn
Initiation à la logique programmable - D.Genet - Janvier 2006
134
Langages
de description
Usage de la primitive DFF
compteur[].prn
compteur[].d
d
prn
q
compteur[].q
compteur[]
compteur[].clk
clk clrn
compteur[].clrn
compteur[].clk = CLOCK signifie que les 4 bascules
recoivent le signal CLOCK sur leur entrée horloge.
compteur[].clrn = !RAZ signifie que toutes les bascules
sont remises à zéro de façon asynchrone si RAZ est haut.
Initiation à la logique programmable - D.Genet - Janvier 2006
135
Langages
de description
Usage par défaut
compteur[]
d
prn
q
compteur[]
compteur[]
compteur[].clk
clk clrn
compteur[] = compteur[]+ 1;
est équivalent à
compteur[].d = compteur[].q + 1;
Par défaut, l’utilisation d’une structure DFF dans une équation
est telle que le membre de gauche désigne l’entrée D tandis
que l’élément de droite concerné désigne la sortie Q.
Initiation à la logique programmable - D.Genet - Janvier 2006
136
Langages
de description
AHDL : opérateurs arithmétiques
compteur[] =(((compteur[]+1)
& !((compteur[]==9)& DIX)
)& VALID
#(compteur[] & !VALID)
)& !RAZ ;
Outre les opérateurs logiques (&, #, !) l’expression de compteur[ ]
utilise des opérateurs arithmétiques : addition +, égalité ==.
D’autres opérateurs sont disponibles :
- soustraction : –
- inégalité :
!=
- ordre : >, <, >=, <=
Initiation à la logique programmable - D.Genet - Janvier 2006
137
Langages
de description
AHDL : opérateurs logiques littéraux
AHDL supporte à la fois les opérateurs logiques symboliques
(&, #, !,$) et leur correspondants littéraux :
& => and
# => or
! => not
$ => xor
On peut donc écrire dans ce langage :
compteur[] =(((compteur[]+1)
and not((compteur[]==9)and DIX)
)and VALID
or(compteur[] and not VALID)
)and not RAZ ;
L’utilisation de l’une ou l ’autre forme des opérateurs logiques est une question
de style personnel, de même que le choix de majuscules ou minuscules.
Initiation à la logique programmable - D.Genet - Janvier 2006
138
Langages
de description
Équations structurées : if .. then .. else
Les structures conditionnelles constituent une alternative
lisible par rapport aux équations directes :
if not RAZ then
if VALID then
if not(DIX and compteur[]==9) then
compteur[] = compteur[]+1;
end if;
else
compteur[]= compteur[];
end if;
end if;
Attention aux alternatives non explicitées, pour lesquelles les
signaux concernés ne sont pas maintenus…
Initiation à la logique programmable - D.Genet - Janvier 2006
139
Langages
de description
Alternative implicite de if
Lorsque l’alternative à une expression booléenne n’est pas
précisée explicitement, elle produit implicitement une remise
à zéro du signal concerné !
Ainsi les équations
compteur[]= compteur[]+1)and not RAZ;
ou
if not RAZ then
compteur[] = compteur[]+1;
end if;
impliquent que compteur[]prendra la valeur 0 au prochain
front actif d ’horloge si RAZ est vrai...
Initiation à la logique programmable - D.Genet - Janvier 2006
140
Langages
de description
Alternative implicite : cas des timers
Si certains états d’un système doivent être soumis à temporisation,
la remise à zéro implicite est très commode !
Ainsi si le timer TEMPO est piloté de la façon suivante :
if (E2 or E5) then
TEMPO[] = TEMPO[]+1;
end if;
ce timer sera automatiquement remis à zéro sur tout autre
état que ceux mentionnés dans la condition (E2 # E5)
Initiation à la logique programmable - D.Genet - Janvier 2006
141
Description de séquencement complexe
En dehors de la méthode des tables des transitions,
la mise en équations d’un système séquentiel peut
passer par des représentations symboliques :
RESEAU de PETRI
GRAPHSET
GRAFCET
GRAPHCET
GRAPHE D’ETAT
...
Le choix de l’une ou l’autre représentation est une question de
style personnel. Le réseau de Pétri ne sera pas abordé ici, son
utilisation étant plutôt réservée à la modélisation de systèmes à
fort parallélisme.
Initiation à la logique programmable - D.Genet - Janvier 2006
142
GRAFCET
Exemple de grafcet
0
c1
1
A1
T=t1
A2
T=t2
ft1
2
c2.ft2
.
A3
3
c2.c3
c2.c3
4
A4
A5
5
1
c4
6
T=t3
ft3
A4
c5.c2
c1.c5
7
A3
c6
A1
8
c7
- entrées : c1, ft1, c2, ft2, c3, c4, c5, ft3, c6, c7
- sorties : A1, A2, A3, A4, A5
- nombre d'étapes : 9
Initiation à la logique programmable - D.Genet - Janvier 2006
143
GRAFCET
Grafcet : principes de la formalisation
étape
transition
réceptivité
1
1
c1
c1
2
2
Le système restera sur l’étape 1 tant que le front actif
de l’horloge trouve la condition c1 fausse.
Ne pas représenter
l’alternative à C1 :
elle est implicite
dans le grafcet.
1
c1
c1
2
Initiation à la logique programmable - D.Genet - Janvier 2006
144
GRAFCET
Grafcet : chronogrammes d’une transition
Horloge
C1
E1
c1
E2
E1
E2
Initiation à la logique programmable - D.Genet - Janvier 2006
145
GRAFCET
Grafcet : transition synchrone
Attention aux implications du synchronisme :
Horloge
C1
E1
c1
E2
E1
E2
C’est l’état AVANT le front actif de l’horloge qui
conditionne l’état suivant !
Initiation à la logique programmable - D.Genet - Janvier 2006
146
GRAFCET
Grafcet : étape fugitive
Étape sans maintien
Horloge
E1
C1
c1
E1
E2
E2
1
E3
E3
Une étape sans maintien dure
une période de l’horloge.
Initiation à la logique programmable - D.Genet - Janvier 2006
147
GRAPHE
Graphe d’état
(ou diagramme d’état)
Modèle de Moore
01,10
S0
0
00,11
Alphabet d ’entrée :
e1,e2
S1
1
XX
Alphabet de sortie :
z
Chaque état que peut prendre le système représenté est
figuré par une bulle nommée : S0, S1 par exemple.
Chaque bulle mentionne l ’état des sorties.
Les transitions d’un état à l ’autre sont représentées par
des flèches accompagnées de l’état des entrées.
Une seule transition peut être effectuée sur chaque
front actif de l ’horloge.
Initiation à la logique programmable - D.Genet - Janvier 2006
148
GRAPHE
Graphe d’état : exemple 1
01,10
S0
0
00,11
Alphabet d ’entrée :
e1,e2
S1
1
XX
Alphabet de sortie :
z
L ’exemple ci-dessus concerne un système à 2 états,
2 entrées et 1 sortie.
Le système reste en S0 tant que les eux entrées dont
différentes.
Il passe en S1 si les deux entrées sont identiques.
Une fois passé en S1, le système y reste maintenu
jusqu’à initialisation qui le ramène implicitement en S0
Initiation à la logique programmable - D.Genet - Janvier 2006
149
GRAPHE
Graphe d’état : exemple 2
Compteur / décompteur modulo 4 : 4 états
Entrées : up, init;
Sorties : compteur[1..0];
X1
S0
0
1X
10
0X
00
S3
3
X1
00
10
S2
2
S1
1
00
10
X : état indifférent
Initiation à la logique programmable - D.Genet - Janvier 2006
150
Modes d’implémentation d’un
système séquentiel
Pour un système présentant n états,
l’alternative est :
Implémentation One Hot Encoding
n bascules D, donc n cellules logiques
Implémentation Finite State Machine (FSM)
Registre de p bascules D, donc p cellules logiques
avec p tel que 2p-1 < n <= 2p
A priori, économie de cellules, car p < n
Initiation à la logique programmable - D.Genet - Janvier 2006
151
Implémentation
OHE
Implémentation One Hot Encoding
Prenons le cas d’une représentation par grafcet :
Chaque étape E du grafcet est matérialisée par une bascule D.
La détermination de l’excitation de l ’entrée D se fait en se
posant les questions suivantes :
Après quelle(s) étape(s) et à quelle(s) condition(s)
l’étape E doit-elle être activée ?
1 ou plusieurs termes d ’activation
A quelle(s) conditions l’étape E activée doit-elle
maintenue activée ?
0 ou 1 terme de maintien
Initiation à la logique programmable - D.Genet - Janvier 2006
152
Implémentation
OHE
Mise en équations : exemple 1
L’étape 2 est implémentée par une bascule D
E2 dont l’excitation est régie par l’équation :
E1
c1
E2
E2 = E1 & C1 # E2 & !C2 ;
c2
E3
Terme d ’activation
Terme de maintien
Initiation à la logique programmable - D.Genet - Janvier 2006
153
Implémentation
OHE
Exemple 1 : commentaires
Activation : E2 ne peut être
activée que si le système se
trouve en E1 et que c1 est
vrai.
E2 = E1 & C1 # E2 & !C2 ;
Maintien : le système reste en E2 tant
que la condition C2 est fausse.
Initiation à la logique programmable - D.Genet - Janvier 2006
154
Implémentation
OHE
Exemple 1 : variante IF
E2 = E1 & C1 # E2 & !C2 ;
Cette équation peut être exprimée par le truchement
d’une structure IF :
if C1 then E2 = E1;
elsif not C2 then E2 = E2;
end if;
A noter que l’alternative else E2 = GND est implicite.
Initiation à la logique programmable - D.Genet - Janvier 2006
155
Implémentation
OHE
Exemple 1 : Synthèse logique
Maintien : E2 & !C2
C2
C1
D
Q
E2
E1
CLK
Activation : E1 & C1
Horloge
Initiation à la logique programmable - D.Genet - Janvier 2006
156
Implémentation
OHE
Mise en équations : exemple 2
E1
c1
L’étape 2 est implémentée par une bascule D
E2 dont l’excitation est régie par l’équation :
E2
c2
E3
c3
E2 = E1 & C1
# E2 & ! (C2 # C3) ;
E4
Le terme de maintien est l’état de l’étape considérée
conditionné par le complément de la somme des réceptivités
de sortie.
Initiation à la logique programmable - D.Genet - Janvier 2006
157
Implémentation
OHE
Exemple 2 : remarque
L’équation associée à l’étape 2 doit s’écrire
systématiquement, sans simplifications qui
compliqueraient toute modification ultérieure.
E1
c1
E2 = E1 & C1
C3)#; C4) ;
# E2 & ! (C2 # C3
E2
c2
E3
c3
E4
c4
5
On insiste : le terme de maintien est l’état de l’étape conditionné
par le complément de la somme des réceptivités
de sortie.
Initiation à la logique programmable - D.Genet - Janvier 2006
158
Implémentation
OHE
Exemple 2 : variante IF
E2 = E1 & C1
# E2 & ! (C2 # C3 # C4) ;
Cette équation peut être exprimée par le truchement
d’une structure IF :
if C1 then E2 = E1;
elsif not (C2 or C3 or C4) then
E2 = E2;
end if;
Initiation à la logique programmable - D.Genet - Janvier 2006
159
Implémentation
OHE
Mise en équations : exemple 3
E1
E0
c1
c0
E2
c2
E3
L’étape 2 est implémentée par une
basculeD E2 dont l’excitation est
régie par l’équation :
E2 = E0&C0 # E1&C1
# E2 & ! C2;
2 termes d’activation
1 terme de maintien
Initiation à la logique programmable - D.Genet - Janvier 2006
160
Implémentation
OHE
Mise en équations : exemple 4
L’étape 2 est implémentée par une bascule D
E2 dont l ’excitation est régie par l ’équation :
E1
c1
E2
A
E2 = E1 & C1;
1
E3
L’action A aura pour équation :
A = E2;
L ’équation de E2.d n’a pas de terme de maintien : l’étape 2 ne
restera donc activée que durant 1 période de l ’horloge.
De même pour l’action A associée à cette étape.
Initiation à la logique programmable - D.Genet - Janvier 2006
161
Implémentation
OHE
Exemple 4 : remarque
L ’équation d ’une action associée
à une ou plusieurs étapes doit s’écrire
uniquement en fonction de celles-ci !
E1
c1
E2
A
c2
E3
L’action A aura pour équation :
A = E2;
Il ne faut surtout pas écrire :
A = E1&c1;
En effet, ici cette expression ne sera vraie que durant une période
de l’horloge alors que l ’action A doit persister ici tant que la
condition c2 est fausse.
Initiation à la logique programmable - D.Genet - Janvier 2006
162
Implémentation
OHE
Mise en équations : exemple 5
Cas de parallélisme :
E1
E3
c1
c2
E2
E4
E2 = E1&c1 # E2&!E4;
E4 = E3&c2 # E4&!E2;
E5 = E4&E2;
1
E5
L ’étape 5 ne peut être activée que si
les étapes 2 et 4 sont activées
parallèlement.
Ce parallélisme, implicite dans le grafcet, doit être
explicité dans les équations.
Initiation à la logique programmable - D.Genet - Janvier 2006
163
Implémentation
OHE
Exercice de mise en équation
Unité de transbordement entre 2 convoyeurs
Pour cet automatisme, deux opérations peuvent avoir
lieu en même temps.
Initiation à la logique programmable - D.Genet - Janvier 2006
164
Implémentation
OHE
Grafcet du transbordeur
1
pièce devant poussoir1 = dp1
2
Avance poussoir 1
pièce devant poussoir 2 = dp2
3
Avance poussoir 2
6
Recul poussoir 1
.
pièce évacuée = pe
4
Recul poussoir 2
poussoir 1 en arrière = p1a
7
poussoir 2 en arrière = p2a
5
1
Initiation à la logique programmable - D.Genet - Janvier 2006
165
Implémentation
OHE
Equations du transbordeur
Séquencement :
E2
= (E1&dp1 # E2&!dp2)&!INIT;
E3
E4
E5
E6
=
=
=
=
E7
E1
= (E6&p1a # E7&!E5)&!INIT;
= (E5&E7 # E1&!dp1 # INIT;
(E2&dp2
(E3&pe
(E4&p2a
(E2&dp2
#
#
#
#
E3&!pe)&!INIT;
E4&!p2a)&!INIT;
E5&!E7)&!INIT;
E6&!p1a)&!INIT;
Actions :
avp1 = E2;
rp1 = E6;
avp2 = E3;
rp2 = E4;
Initiation à la logique programmable - D.Genet - Janvier 2006
166
Implémentation
OHE
Transbordeur : initialisation
Autre intégration de l’initialisation dans le séquencement :
if INIT then
E1 = VCC;
E[2..7] = 0;
else
E1 = E5&E7
E2 = E1&dp1
E3 = E2&dp2
E4 = E3&pe
E5 = E4&p2a
E6 = E2&dp2
E7 = E6&p1a
end if;
#
#
#
#
#
#
#
E1&!dp1;
E2&!dp2;
E3&!pe;
E4&!p2a;
E5&!E7;
E6&!p1a;
E7&!E5;
(VCC = niveau 1 pour un bit ; GND = niveau 0 pour 1 bit )
Initiation à la logique programmable - D.Genet - Janvier 2006
167
Implémentation
OHE
Initialisation automatique
En conception, les PLDs sont en général associés à un circuit
de remise à zéro globale, actif à la mise sous tension.
Cette situation peut être mise à profit pour une initialisation
automatique :
if INIT # (E[]==0)then
E1 = VCC;
E[2..7] = 0;
else
E1 = E5&E7 # E1&!dp1;
E2 = E1&dp1 # E2&!dp2;
...
end if;
Initiation à la logique programmable - D.Genet - Janvier 2006
168
Implémentation
OHE
Types d’action
Dans ce grafcet de niveau 2 le signal A est
vrai lorsque les étapes 2 et 4 sont actives.
Il est faux sur les autres étapes.
E1
c1
E2
A
Le signal A est un circuit combinatoire
tel que
A = E2 # E4;.
c2
E3
c3
E4
A
Dans ce second grafcet, le signal A
est mis à 1 lors de l ’étape 2 .
Il est remis à 0 lors de l ’étape 4.
Le signal A est une mémoire qui
change d’état aux fronts d’horloge
qui suivent ceux qui activent les
étapes E2 et E4.
E1
c1
E2
A=1
c2
E3
c3
E4
Initiation à la logique programmable - D.Genet - Janvier 2006
A=0
169
Implémentation
OHE
Actions à mémoire : équations
E1
A : DFF;
c1
E2
A=1
…
c2
A.clk = clock;
A = E2 # A&!E4;
E3
c3
E4
A=0
Terme
d ’activation
Terme
de maintien
D’une façon générale le terme de maintien est le signal
mémoire conditionné par le complément de la somme des
étapes qui doivent remettre à zéro ce signal.
Exemple :
A = E2 # A&!(E0 # E4);
E0 est par exemple l’étape d ’initialisation du système.
Initiation à la logique programmable - D.Genet - Janvier 2006
170
Implémentation
OHE
Comptage
C=0
E0
c1
E1
C[3..0] : DFF;
…
...
C=C+1
C[].clk = clock;
C[] = (C[]+1)&(E1#E3)
?
# C[]&!(E0#E1#E3);
# C[]&!E0;
c2
E2
c3
E3
C=C+1
1
Le comptage et le maintien
doivent être exclusifs !
Attention : si lors de l ’étape E3 le compteur C s’incrémentera
d’une unité, il n ’en est pas de même pour l’étape E1 : le
compteur C s’incrémentera tant que la condition c2 est fausse !
Initiation à la logique programmable - D.Genet - Janvier 2006
171
Implémentation
OHE
Comptage : remarque sur le maintien
C=0
E0
C[] = (C[]+1)&E1 # C[]&!E0
c1
E1
C=C+1
c2
E2
L’équation ci-dessus peut paraître a priori
correcte. Cependant, il s’avère que le
terme de maintien reste vrai lorsque le
terme d’activation est vrai.
Le pilote C[ ].d sera alors le résultat d’un OU logique entre l ’état
courant C[ ].q du compteur et ce même état incrémenté de 1...
Exemple sur 4 bits :
Etat actuel
0
1
3
7
C[]
0000
0001
0011
0111
C[]+1
0001
0010
0100
1000
C[].d
0001
0011
0111
1111
Etat futur
1
3
7
15
Initiation à la logique programmable - D.Genet - Janvier 2006
172
Implémentation
OHE
Comptage : activation et maintien
C[] = (C[]+1)&E1 # C[]&!E0
n
n
E0=0
D
E1=1
Q
C
+
1
CLK
Horloge
C
0
1
3
7
15
31
63
Une telle progression est symptomatique d’une
non exclusion entre l’activation et le maintien !
Initiation à la logique programmable - D.Genet - Janvier 2006
173
Implémentation
OHE
Comptage : validation correcte
C=0
E0
c1
E1
C=C+1
c2
E2
L ’équation correcte du compteur C
sera :
C[] = (C[]+1)&E1 # C[]&!(E1#E0);
E3
Une variante consiste à énumérer dans le terme de maintien
la somme des étapes où ce maintien est implicite :
C[] = (C[]+1)&E1 # C[]&(E2#E3);
L’expression E2#E3 est le complément de E0#E1 par rapport au Grafcet considéré…
Initiation à la logique programmable - D.Genet - Janvier 2006
174
Implémentation
OHE
Temporisation
L ’étape 2 valide l’incrémentation
d’un compteur tempo par le
signal en_tempo.
E1
c1
E2
en_tempo
L ’étape 2 est maintenue tant
que le compteur tempo n ’a pas
atteint la valeur N.
tempo == N
E3
1
tempo[15..0] : DFF;
…
tempo[].clk = clock;
tempo[].d
tempo[]
= (tempo[]+1)&
= ?
E2;
Il n’est pas nécessaire d’expliciter la remise à zéro du compteur
de temporisation : on ne met pas de terme de maintien...
Initiation à la logique programmable - D.Genet - Janvier 2006
175
Implémentation
OHE
Puits
1
Il peut arriver que l’on veuille exceptionnellement
bloquer un système : pour on l’aiguille vers un
« puits »
c1
2
E4 = E2&C3 # E4;
c2
3
c3
4
C3
0
E2
D
Q
E4
CLK
puits
Initiation à la logique programmable - D.Genet - Janvier 2006
176
Implémentation
OHE
Exercice : chronomètre
Un chronomètre peut être assimilé à un compteur
cadencé par une horloge CLOCK, avec :
Validation du comptage par signal START.
Arrêt du comptage par signal STOP.
Remise à zéro par signal RAZ.
Ici, le compteur est BCD et compte de 0 à 99.
Initiation à la logique programmable - D.Genet - Janvier 2006
177
Implémentation
OHE
Chronomètre : grafcet
0
INIT
Actions :
START
1
VALID
STOP
VALID : validation
du comptage
2
START
INIT : remise à zéro
du compteur.
RAZ
Initiation à la logique programmable - D.Genet - Janvier 2006
178
Implémentation
OHE
Chronomètre : équations
Déclarations de ressources
E[0..2] : DFF; -- séquenceur
UNIT[3..0],DIZ[3..0] : DFF; -- compteur
Equations du séquenceur
E[].clk = CLOCK;
if E[]==0 then
E0.d = VCC;
else
E0.d
E0
= E2&RAZ
= E2&RAZ
#E0&!START;
#E0&!START;
E1.d
E1
= (E0#E2)&START
= E0&START # E1&!STOP;
# E1&!STOP;
E2.d
E2
= E1&STOP
= E1&STOP
# E2&!(START
# E2&!(START
# RAZ);
# RAZ);
end if;
L’équation de E1.d est fausse, pourquoi ?
Initiation à la logique programmable - D.Genet - Janvier 2006
179
Implémentation
OHE
Chronomètre : équations (2)
Equations des actions
INIT = E0;
VALID = E1;
Equations du compteur
--unités
UNIT[].clk = CLOCK;
UNIT[] = ((UNIT[]+1)&(UNIT[]!=9)&VALID)
#(UNIT[]&!VALID))&!INIT;
--dizaines
DIZ[].clk = CLOCK;
DIZ[] = ((DIZ[]+1)&(DIZ[]!=9)&(UNIT[]==9)&VALID)
#(DIZ[] &!(VALID # UNIT[]==9))&!INIT;
Initiation à la logique programmable - D.Genet - Janvier 2006
180
Implémentation
OHE
Chronomètre : unités
Expression structurée de UNIT[ ].d :
if not INIT then
if VALID then
if UNIT[]!=9
UNIT[] = UNIT[]+1;
end if;
else
UNIT[] = UNIT[];
end if;
end if;
Initiation à la logique programmable - D.Genet - Janvier 2006
181
Implémentation
OHE
Chronomètre : dizaines
Expression structurée de DIZ[ ].d :
if not INIT then
if VALID & UNIT[]==9 then
if DIZ[]!=9
DIZ[] = DIZ[]+1;
end if;
else
DIZ[] = DIZ[];
end if;
end if;
Initiation à la logique programmable - D.Genet - Janvier 2006
182
Implémentation
OHE
Exercice : Aiguillage
Des bouteilles convoyées sur une file arrivent à
un aiguillage à 3 voies V1, V2, V3.
La logique à associer à cet aiguillage et à développer
ici doit être telle que les bouteilles seront
dirigées vers les 3 voies successivement par
paquets de 5 et ceci de façon cyclique.
Initiation à la logique programmable - D.Genet - Janvier 2006
183
Implémentation
OHE
Aiguillage : vue externe
Ports d’entrée / sortie
B
aiguillage
V1
V2
reset
clock
V3
Arrêt normal
Arrêt urgence
B : signal délivré par un capteur de passage de bouteille
Initiation à la logique programmable - D.Genet - Janvier 2006
184
Implémentation
OHE
Aiguillage : chronogrammes
Bouteille
V1
V2
V3
Initiation à la logique programmable - D.Genet - Janvier 2006
185
Implémentation
OHE
Aiguillage : ressources
Compteur de bouteilles (modulo 5)
Permutateur de voies
Un séquenceur général :
Sensibilités : - détection de bouteille B
- état du compteur CB
- arrêt normal AN
- état de la voie 3
Actions : - validation du compteur (EN_CB)
- remise à zéro synchrone (CS_CB)
- permutation circulaire des voies (EN_PV)
et initialisation sur la voie 1 (INIT_PV))
Initiation à la logique programmable - D.Genet - Janvier 2006
186
Implémentation
OHE
Aiguillage : schéma structurel
aiguillage
Compteur
de
Bouteilles
V1
CB
Permutateur
de
Voies
V2
V3
reset
clock
B
Séquenceur
AN
AU
Initiation à la logique programmable - D.Genet - Janvier 2006
187
Implémentation
OHE
Aiguillage : grafcet du séquenceur
reset
E0
CS_CB
INIT_PV
B
E1
EN_CB
1
E2
!B
E3
(CB!=5)
&B
(CB==5) &!(AN&V3)
E4
EN_PV
CS_CB
1
E5
B
Initiation à la logique programmable - D.Genet - Janvier 2006
188
Implémentation
OHE
Aiguillage : grafcet du permutateur
V1
E4
V2
E0
Le permutateur
est initialisé sur
V1 par E0
E4
V3
E4 # E0
Initiation à la logique programmable - D.Genet - Janvier 2006
189
Implémentation
FSM
Implémentation FSM
Chaque état discernable du système est représenté
par celui d’un registre (groupement de bascules D).
Ce registre (registre d’état ou séquenceur) aura le
nombre p de bits nécessaires pour représenter les
N états identifiés, soit donc p tel que
2P-1 < N <= 2P
L’implémentation du séquenceur en mode FSM demandera
donc les équations des entrées D des P bascules D, fonctions
à la fois des états du séquenceur et de ceux des signaux
externes intervenant dans la succession des états.
Initiation à la logique programmable - D.Genet - Janvier 2006
190
Implémentation
FSM
Implémentation FSM : exemple
Détecteur d’états consécutifs
e
Détecteur
z
Horloge
La sortie z passe à 1 si l ’entrée e est restée à 1
sur au moins 3 fronts d ’horloge consécutifs.
Initiation à la logique programmable - D.Genet - Janvier 2006
191
Implémentation
FSM
Détecteur : représentation
Le système a quatre états possibles selon qu’il a
détecté l’entrée au niveau 1 sur 0, 1, 2 ou au moins 3
fronts actifs de l ’horloge.
On choisit une représentation par graphe d’état :
Entrée : e;
Sortie : z;
4 états possibles
0
S0
0
1
S1
0
S2
0
1
1
S3
1
0
0
1
0
Initiation à la logique programmable - D.Genet - Janvier 2006
192
Implémentation
FSM
Détecteur : implémentation FSM sous AHDL
Le langage AHDL permet de coder un graphe (ou un grafcet) en
vue d’une implémentation FSM de deux manières :
Saisie directe de la table des transitions
Pour les amateurs de tables !
Leur taille augmente exponentiellement avec
le nombre de variables externes…
Utilisation d’une structure CASE
Structure très pratique, portable généralement dans
les autres langages.
De plus, en AHDL, si elle examine les états d’une
variable de type STATE MACHINE, les maintiens
sont implicites.
Initiation à la logique programmable - D.Genet - Janvier 2006
193
Implémentation
FSM
Détecteur : codage sous forme de table
% Déclaration d'une machine d'état
SS : state machine with states (S0, S1, S2, S3);
...
SS.clk = clock;
% Cadencement de la machine d ’état
...
table
SS, e => SS; % Enumération des éléments de la table
S0, 0 => S0;
S0, 1 => S1;
S1, 0 => S0;
S1, 1 => S2;
S2, 0 => S0;
S2, 1 => S3;
S3, 0 => S0;
S3, 1 => S3;
end table;
Initiation à la logique programmable - D.Genet - Janvier 2006
194
Implémentation
FSM
Détecteur : codage par instruction CASE
% Déclaration d'une machine d'état
SS : state machine with states (S0, S1, S2, S3);
...
SS.clk = clock;
% Cadencement de la machine d ’état
...
case SS is
when S0 =>
if e then SS = S1; end if;
when S1 =>
if e then SS = S2; else SS = S0;
end if;
when S2 =>
if e then SS = S3; else SS = S0;
end if;
when S3 =>
if !e then SS = S0; end if;
end case;
Initiation à la logique programmable - D.Genet - Janvier 2006
195
Détecteur : génération des équations
Puisqu ’il présente 4 états possibles, le système peut
être implémenté par un compteur à 2 bits (B0,B1)
réalisé avec 2 bascules D. A priori les états S0 à S3
correspondront aux états numériques du compteur
(0,1,2,3).
Au plus bas niveau il faut exprimer :
Les équations de chaque entrée D
L’équation de la sortie
Cette dernière est très simple : z = S3;
L ’établissement des équations des entrées D passe par celui de
la table des transitions, déduite directement du graphe d’état.
Initiation à la logique programmable - D.Genet - Janvier 2006
196
Implémentation
FSM
Détecteur : table des transitions
Etat actuel
S0
S0
S1
S1
S2
S2
S3
S3
Entrée e
Etat futur
0
1
0
1
0
1
0
1
S0
S1
S0
S2
S0
S3
S0
S3
B1.d B0.d
0
0
0
1
0
1
0
1
0
1
0
0
0
1
0
1
Les équations de B0.d et B1.d sont déduites de cette table :
B0.d = (S0 # S2 # S3) &e;
B1.d = (S1 # S2 # S3) &e;
Initiation à la logique programmable - D.Genet - Janvier 2006
197
Implémentation
FSM
Détecteur : équations réduites
B0 = (S0 # S2 # S3) &e;
B1 = (S1 # S2 # S3) &e;
Les états S0 à S3 sont les états successifs (0,1,2,3)
d’un compteur 2 bits B0 et B1. Les équations
réduites de l’excitation des bascules seront :
B0 = !B1&!B0&e # B1&!B0&e # B1&B0&e ;
B1 = B1&!B0&e # B1&!B0&e # B1&B0&e ;
Initiation à la logique programmable - D.Genet - Janvier 2006
198
B0 = !B1&!B0&e # B1&!B0&e # B1&B0&e ;
Implémentation
FSM
D
Clk
D
Clk
Q
Q
B0
B1
e
B1 = B1&!B0&e # B1&!B0&e # B1&B0&e ;
Initiation à la logique programmable - D.Genet - Janvier 2006
199
Exercice de synthèse : feux tricolores
Entrées : p1,p2
VOIE 2
Sorties : V1,O1,R1
V2,O2,R2
P2
P1
V2 O2 R2
VOIE 1
R1
O1
V1
Un détecteur de présence de voiture est placé sur
chacune des voies, P1 pour la voie 1, P2 pour la voie 2.
Initiation à la logique programmable - D.Genet - Janvier 2006
200
Exercice de
synthèse
Feux tricolores : spécifications
S 'il y a présence d'un véhicule sur la voie 1 (P1 = 1)
et absence de véhicule sur la voie 2 (P2 = 0),
les feux sont vert pour la voie1 et rouge pour la voie2 ;
cet état persiste tant que la situation dure.
Pour la situation inverse (P1 = 0 et P2 = 1) , les feux
sont bien entendu inversés.
Initiation à la logique programmable - D.Genet - Janvier 2006
201
Exercice de
synthèse
Feux tricolores : spécifications
S'il y a présence ou absence de véhicules
simultanément sur les deux voies (P1 = P2),
les feux changent d'état en respectant la séquence
suivante :
feux1
feux2
Si lors du passage au vert d'une voie, il y a absence
de véhicule sur cette voie, le cycle normal est modifié
pour que le feu de la voie sans véhicule passe à
l'orange à la prochaine impulsion de l'horloge.
Initiation à la logique programmable - D.Genet - Janvier 2006
202
Exercice de
synthèse
Feux tricolores : graphe d ’état
8 états possibles
2 entrées : P1, P2.
6 sorties : V1,O1,R1,V2,O2,R2
Initiation à la logique programmable - D.Genet - Janvier 2006
203
Exercice de
synthèse
Feux tricolores : graphe d ’état
10
S0
V1R2
S7
R1O2
P1P2
00,11
S1
V1R2
01
S6
R1V2
S2
V1R2
10
S3
O1R2
S5
R1V2
00,11
S4
R1V2
01
Initiation à la logique programmable - D.Genet - Janvier 2006
204
Exercice de
synthèse
Feux tricolores : table des transitions
table
SS, P1,P2
S0, 1, 0
S0, 0, 0
S0, 1, 1
S0, 0, 1
S1, X, X
S2, X, X
S3, X, X
S4, 0, 1
S4, 0, 0
S4, 1, 1
S4, 1, 0
S5, X, X
S6, X, X
S7, X, X
end table;
=>
=>
=>
=>
=>
=>
=>
=>
=>
=>
=>
=>
=>
=>
=>
SS;
S0;
S1;
S1;
S3;
S2;
S3;
S4;
S4;
S5;
S5;
S7;
S6;
S7;
S0;
Initiation à la logique programmable - D.Genet - Janvier 2006
205
Exercice de
synthèse
Feux tricolores : sorties
V1 = S0 # S1 # S2;
O1 = S3;
R1 = S4 # S5 # S6 # S7;
V2 = S4 # S5 # S6;
O2 = S7;
R2 = S0 # S1 # S2 # S3;
Initiation à la logique programmable - D.Genet - Janvier 2006
206
Exercice de
synthèse
Feux : implémentation FSM
… ou estimation des ressources nécessaires sur un SPLD.
Le système comporte 8 états possibles : en mode
FSM il faudra 3 bascules, soit 3 cellules logiques.
Ceci à condition que la combinatoire nécessitée
par le séquencement n’exige pas des cellules
supplémentaires.
Les 6 sorties sont toutes fonctions combinatoires
des états Q0, Q1, Q2 des bascules : il faut donc
6 cellules logiques supplémentaires.
Au total, le projet nécessite 9 cellules logiques.
Initiation à la logique programmable - D.Genet - Janvier 2006
207
Exercice de
synthèse
P1 P2
Feux : ressources en mode FSM
D0 = f0(P1,P2,Q0,Q1,Q2)
Q0
D1 = f1(P1,P2,Q0,Q1,Q2)
Q1
D2 = f2(P1,P2,Q0,Q1,Q2)
Q2
V1 = g0(Q0,Q1,Q2)
V1
O1 = g1(Q0,Q1,Q2)
O1
R1 = g2(Q0,Q1,Q2)
R1
V2 = g3(Q0,Q1,Q2)
V2
O2 = g4(Q0,Q1,Q2)
O2
R2 = g6(Q0,Q1,Q2)
R2
Initiation à la logique programmable - D.Genet - Janvier 2006
208
Exercice de
synthèse
Feux : implémentation OHE
Chaque état est implémenté par une bascule :
il faut donc 8 cellules pour le séquencement.
Les 6 sorties sont fonctions combinatoires des
états selon les équations :
V1 = S0#S1#S2;
O1 = S3;
R1 = S4#S5#S6#S7;
V2 = S4#S5#S6;
O2 = S7;
R2 = S0#S1#S2#S3;
Les sorties O1 et O2 ne nécessitent pas de
combinatoire : il faut donc 4 cellules.
Au total, le projet nécessite 12 cellules logiques.
Initiation à la logique programmable - D.Genet - Janvier 2006
209
OHE
vs
FSM
Implémentation : quelle méthode ?
En fait la vraie question est : n machines d’état 1 bit
ou 1 machine d’état p bits (2p-1 < n <= 2p) ?
A priori la machine d’état p bits réclame
intrinsèquement moins de ressources .
Cependant ce bénéfice peut être perdu par la
combinatoire sous-jacente au séquencement et aux
sorties : sa taille peut s’avérer plus importante.
Les outils de synthèse donnent en général le choix
par l’option « one hot encoding » . Si nécessaire,
il suffit d ’essayer les deux cas pour décider.
Initiation à la logique programmable - D.Genet - Janvier 2006
210
OHE
vs
FSM
Grafcet et FSM : restriction
Si le grafcet comporte des étapes activées
en parallèle, l’implémentation FSM
n’est pas applicable.
Un registre d’état à p bits, comme un compteur,
ne peut présenter qu’un seul état à la fois !
Initiation à la logique programmable - D.Genet - Janvier 2006
211
Compteur
CE
Commade
gacche
8
Compteur
CA
Décodeur
clavier
Clavier
4x4
Commade
alarme
Système séquentiel structuré : exemple
TIMER
RAZ
OK
CODE
prédiv
ALARME
GACHE
CLK
DATAAV
PROG
CA
OK
CE
TIMER
ETAT
SEQUENCEUR
Les signaux de validations résultent ici implicitement du décodage
du signal ETAT géré par le séquenceur
Initiation à la logique programmable - D.Genet - Janvier 2006
212
Un outil de
développement :
MAX+II
Initiation à la logique programmable - D.Genet - Janvier 2006
213
Max+II : Structure et entrées
Initiation à la logique programmable - D.Genet - Janvier 2006
214
Max+II : Flot d’un développement
Créer le PROJET
Text or schematic
editor
Compiler
Créer design
(texte ou schéma)
Compilation
fonctionnelle
Waveform
or vector
editor
.acf
.tdf or .gdf
.snf
Créer stimuli
pour le test
.scf
(signaux ou vecteurs)
Simulator
Simuler
or .vec
.scf
OK?
Text or
schematic
editor
Modifier
le design
Suite
Initiation à la logique programmable - D.Genet - Janvier 2006
215
Max+II : Flot d’un développement
(2)
Suite
Compiler
Choix
device
.acf
Compilation
complète
.rpt
.pof
OK?
Floor plan
editor
Compiler
Assignation
pins
.acf
.rpt
.pof
Recompilation
OK?
Modifier design
ou changer
device
Choix système
de programmation
Programmation
Programmer
Test
OK?
Modifier
design
Recette
Initiation à la logique programmable - D.Genet - Janvier 2006
216
Max+II : Structure d’un fichier .tdf
Une description en AHDL (langage propriétaire Altera) débouche
sur un fichier texte .tdf, dont la structure minimale est la suivante :
Section titre : (optionnel) :
title "controleur_video";
Section subdesign (requis) :
subdesign <nom du projet> (
-- déclaration des E/S du projet
)
Section variable (requis en cas de ressources internes)
variable
E[7..0] : DFF;
CPT[3..0]:DFF;
Section logique (requis : contient toutes les équations)
begin …
end;
Initiation à la logique programmable - D.Genet - Janvier 2006
217
Section subdesign
Cette section énumère les variables externes (entrées
et sorties) du système en précisant leur nature :
SUBDESIGN synchro (
raz, clock, valid, oe : INPUT;
alarm : OUTPUT;
affich[3..0] : OUTPUT;
data[7..0] : BIDIR;
)
Le mot clé SUBDESIGN doit être suivi du nom du projet décrit
dans le fichier, qui doit porter le même nom : ici, il s'agira d'un
fichier synchro.tdf.
affich[3..0] et data[7..0] sont des vecteurs de bits : affich[ ] est
un registre de 4 bits composé de affich3, affich2, affich1, affich0
(notés aussi affich[3], affich[2], affich[1] et affich[0]).
Par défaut affich3 est considéré comme le bit de poids fort
du groupe affich[ ].
Initiation à la logique programmable - D.Genet - Janvier 2006
218
Section variable
Cette section, bien qu'à caractère optionnel, est en
général requise : elle sert à déclarer des variables
internes au design, avec leur type.
Elle sert aussi à préciser le type des variables de
sortie externes, combinatoires par défaut.
VARIABLE
affich[3..0] : DFF ;
etape[12..0] : DFF;
compteur_zero : NODE;
SS : MACHINE WITH STATES (s0, s1, s2, s3);
NODE désigne une variable combinatoire interne.
Initiation à la logique programmable - D.Genet - Janvier 2006
219
Section logique
Cette section est évidemment requise : elle contient les
équations décrivant le système projeté.
Elle est encadrée par les délimiteurs BEGIN ..
END;
Les équations directes ou structurées sont
insérées dans cette section selon un ordre
indifférent.
On peut cependant pour une meilleure
lisibilité regrouper les équations par parties
opératives concernées
Initiation à la logique programmable - D.Genet - Janvier 2006
220
Initiation à la logique programmable - D.Genet - Janvier 2006
221
Initiation à la logique programmable - D.Genet - Janvier 2006
222
Initiation à la logique programmable - D.Genet - Janvier 2006
223
Initiation à la logique programmable - D.Genet - Janvier 2006
224
Initiation à la logique programmable - D.Genet - Janvier 2006
225