à la logique programmable

Présentation au sujet: "à la logique programmable"— Transcription de la présentation:

1 à la logique programmable
Initiation à la logique programmable

2 Typologie des circuits logiques
Un système électronique numérique pourra être implémenté avec des circuits logiques de divers types : standards configurables séquentiables 1 fonction par circuit PAL, CPLD FPGA Microprocesseurs Microcontrôleurs DSP Mixtes : FPGA + MICRO + RAM à mémoire spécialisés RAM, ROM Périphériques standards, ASICs SOC (System On Chip)

3 Les composants programmables
Typologie des circuits logiques Les composants programmables à configuration interne à configuration interne figée programmable (microprocesseurs) (PLDs, CPLDs, FPGA,...) Langages de Langages de programmation : Méthodes & description : Assembleur, Outils de Abel, AHDL langage haut niveau conception langage haut niveau (C, java...) (VHDL,Verilog) Séquence Fichier de d'instructions configuration

4 Intérêt des PLDs Intégration Temps réel Développement Confidentialité
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é

5 Intégration de systèmes par les PLDs
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 à portes 1000 à x portes

6 Intégration fonctionnelle
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

7 Temps réel : parallélisme
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

8 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

9 Développement aisé Existence d’outils de développement totalement
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…

10 Développement flexible
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. ...

11 Coûts Tous les arguments cités en faveur des PLDs ont une
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.

12 Confidentialité Sauf recopie intégrale d’un système intégrant des PLDs
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é).

13 Microcontrôleur ou PLDs ?
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.

14 Limites des PLDs Tout en présentant d’indéniables qualités, les PLDs
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. Quantité Coût total PLDs 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. Asics

15 Les PLDS : Approche Actel Altera AMD Philips Vantis Xilinx
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 Altera DG France : ancien ESEO AMD Philips Vantis Xilinx DG France : ancien ESEO

16 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). 48x16x x 8 = 1920 points de configuration

17 FPLA : analyse de la configuration
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 : +5V e 1 2 3 P1 Le terme produit P1 est issu d’un ET câblé tel que : P1 = e1.e2.e3 La sortie S1 est issue d’un OU câblé tel que : +5V P1 P2 P3 S1 S1 = P1 + P3 Ici P3 = 0 ; il reste : S1 = e1.e2.e3

18 FPLA : représentation symbolique
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 S2

19 FPLA : synthèse Au final, l’organisation d’un FPLA s’appuie sur
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.

20 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é.

21 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

22 Un SPLD : le PAL (Programmable Array Logic) Exemple : PAL16L8
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) .

23 PAL16L8 : la cellule Les lignes sont regroupées
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

24 PAL16L8 : l ’organisation 6 Entrées externes 10 Entrées externes
Les SPLDs PAL16L8 : l ’organisation 6 Entrées externes ou rétroactions 10 Entrées externes Réseau programmable 8x10lignes / 32 colonnes Pin I/O (10 lignes) Cellule logique Buffer 3 états 8 cellules logiques chevauchent un réseau de 32 colonnes

25 Exercice : Contrôleur d’interruption
Les SPLDs Exercice : Contrôleur d’interruption I0 I1 I2 I3 I4 I5 I6 I7 /IRQ 3 A[2:0] Contrôleur d ’IT 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

26 Contrôleur d’IT : Table des états
Les SPLDs Contrôleur d’IT : Table des états I7 I6 I5 I4 I3 I2 I1 I0 /IRQ A2 A1 A0 S1 X X X X X X X S2 X X X X X X S3 X X X X X S4 X X X X S5 X X X S6 X X S7 X S S X X 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.

27 Contrôleur d’IT : Equations sources
Les SPLDs Contrôleur d’IT : Equations sources Equations des états : (syntaxe ABEL ou AHDL) S1 = I0; S2 = I1 & !I0; S3 = I2 & !I1 & !I0; S4 = I3 & !I2 & !I1 & !I0; S5 = I4 & !I3 & !I2 & !I1 & !I0; S6 = I5 & !I4 & !I3 & !I2 & !I1 & !I0; S7 = I6 & !I5 & !I4 & !I3 & !I2 & !I1 & !I0; S8 = I7 & !I6 & !I5 & !I4 & !I3 & !I2 & !I1 & !I0; S9 =!I7 & !I6 & !I5 & !I4 & !I3 & !I2 & !I1 & !I0; Equations des sorties : Attention : les buffers du PAL16L8 sont inverseurs. Il faut alors exprimer les inverses des sorties désirées. !IRQ = S9; !A0 = S1 # S3 # S5 # S7; !A1 = S1 # S2 # S5 # S6; !A2 = S1 # S2 # S3 # S4;

28 Contrôleur d’IT : configuration du PAL
Les SPLDs Contrôleur d’IT : configuration du PAL I7 /IRQ I6 A0 I5 A1 I4 A2 I7 I6 I5 I4 I3 I2 I1 I0

29 Exercice : décodeur d’adresse
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 décodeur A[15..0] CS0 CS1 CS2 En première approximation le décodeur se présentera comme suit :

30 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. A15..A12 A11..A8 CS0 CS1 CS2 0000->3fff plage0 4000->6fff 7000->7bff plage1 7c00->ffff plage2 Les 6 bits de poids fort suffisent pour ce décodeur

31 Décodeur : équations sources
Les SPLDs Décodeur : équations sources A[15..10] CS0 décodeur 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;

32 Décodeur : équations réduites
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 & A14 & !A10 # !A15 & A14 & !A11 # !A15 & A14 & !A12 # !A15 & A14 & !A13); !CS2 = A14 & A13 & A12 & A11 & A10 # A15;

33 Décodeur : fichier de configuration
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* L * L * L * L * L * L * L * L * L * L * Ce fichier ne désigne que les lignes de la matrice intervenant dans le projet : les ‘ 1 ’ correspondent aux fusibles à couper.

34 Décodeur : programmation du PAL
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 A14 A13 A12 A11 A10 A15 A14 A13 CS0 CS1 CS2

35 Programmation d ’un SPLD : synthèse
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

36 Un PAL pour le séquentiel : PAL16R8
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.

37 Un PAL plus flexible : PALCE16V8
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

38 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.

39 PALCE16V8 : le XOR programmable
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.

40 Rôle du XOR programmable
Les SPLDs Rôle du XOR programmable Exemple : soit l ’équation réduite : E8 = !init &pbd &!x &!y &!test & E8 # !init &pbc & x & y &!test & E8 # !init &pba & x &!y &!test & E8 # !init &pba &!x & y &!test & E8 # !init &pbd &!x &!y & X7 # !init &pbc & x & y & E7 # !init &pba & x &!y & E7 # !init &pba &!x & y & E7 # !init &pbd &!x &!y & E7 # !init &test & E7 ; 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.

41 Rôle du XOR programmable (2)
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 &!x &!y &!test # !pbc & x & y &!test # !pba & x &!y &!test # !pba &!x & y &!test # !E7 &!E8 # !E7 &!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.

42 Saturation de la cellule : problème
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.

43 Saturation de la cellule : exemple
Les SPLDs Saturation de la cellule : exemple cellule1 a b c d e cellule2 /aux /Y /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;

44 Message d’inadéquation (1)
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.

45 Message d’inadéquation (2)
Les SPLDs Message d’inadéquation (2) Le projet demande plus de cellules logiques que la cible choisie n’en possède.

46 Une variante aux PALs : le GAL
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

47 GAL22V10 : la cellule 8 à 16 entrées
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

48 Exercice : bascule toggle
Les SPLDs Exercice : bascule toggle Q D Clk Q T CS Configurer la matrice de cette cellule pour avoir une bascule T (‘toggle’) avec clear synchrone

49 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.

50 (« routage » nécessaire entre les E/S et les blocs du CPLD)
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

51 Famille EPM7000 (Altera) : organisation
Les CPLDs Famille EPM7000 (Altera) : organisation LAB : logic Array Block PIA : Programmable Interconnection Array

52 Famille EPM7000 (Altera) : la cellule
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.

53 Famille EPM7000 (Altera) : les expanders
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é.

54 Famille EPM7000 (Altera) : les expanders (2)
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.

55 Famille EPM7000S (Altera) : les blocs E/S
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.

56 Famille EPM7000 (Altera) : les puces
Les CPLDs Famille EPM7000 (Altera) : les puces EPM7xxxS : programmable in situ

57 Famille EPM7000 (Altera) : rapidité
Les CPLDs Famille EPM7000 (Altera) : rapidité -5 correspond à un temps de propagation tpd = 5ns

58 Famille EPM7000 (Altera) : les boîtiers
Les CPLDs Famille EPM7000 (Altera) : les boîtiers

59 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)

60 Combinatoire implémentable par des L.U.T. (Look Up Table) = mémoire
Les FPGAs Les FPGAs (2) Combinatoire implémentable par des L.U.T. (Look Up Table) = mémoire Entrées Sortie n 1 adresse LUT donnée Lignes et colonnes d’interconnexion programmables entre les cellules et les blocs E/S

61 (Field Programmable Gate Array)
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.

62 FPGAs : structure générale
Les FPGAs FPGAs : structure générale Lignes d’interconnexions Cellule logique Blocs E/S NB :La matrice va de 10x10 à 100x100 et plus !

63 FPGAs : structure détaillée
Les FPGAs FPGAs : structure détaillée

64 Les FPGAs FPGAs : RAM embarquée Position centrale: minimisation desTpd

65 FPGAs : structure fonctionnelle
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.

66 FPGA Exemple 1 : XC4000 (Xilinx)
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

67 XC4000 : la cellule CLB : Configurable Logic Block
Les FPGAs XC4000 : la cellule CLB : Configurable Logic Block (version combinatoire : 3 générateurs de fonctions F,G,H)

68 XC4000 : la mémoire répartie
Les FPGAs XC4000 : la mémoire répartie (version mémoire : organisation 16x2 bits)

69 XC4000 : les interconnexions
Les FPGAs XC4000 : les interconnexions PSM : Programmable Switches Matrice

70 XC4000 : les interconnexions, détail
Les FPGAs XC4000 : les interconnexions, détail

71 Les FPGAs XC4000 : Bloc E/S

72 XC4000 : exemple de routage Les FPGAs

73 XC4000 : la famille * 20 à 30 % de la RAM est utilisée dans un projet.
Les FPGAs XC4000 : la famille * 20 à 30 % de la RAM est utilisée dans un projet.

74 FPGA Exemple 2 : ACEX (Altera)
Les FPGAs FPGA Exemple 2 : ACEX (Altera) organisation

75 FPGA Exemple 2 : ACEX (Altera)
Les FPGAs FPGA Exemple 2 : ACEX (Altera) La cellule logique

76 FPGA Exemple 2 : ACEX (Altera)
Les FPGAs FPGA Exemple 2 : ACEX (Altera) L’élément Logique

77 FPGA Exemple 2 : ACEX (Altera)
Les FPGAs FPGA Exemple 2 : ACEX (Altera) 3 à 12 EAB (Embedded Array Block) 1 EAB bits Les EAB

78 FPGA Exemple 3 : Virtex 2 pro (Xilinx)
Les FPGAs FPGA Exemple 3 : Virtex 2 pro (Xilinx)

79 Virtex 2 pro : organisation générale
Les FPGAs Virtex 2 pro : organisation générale organisation

80 Virtex 2 pro : la cellule logique
Les FPGAs Virtex 2 pro : la cellule logique La cellule logique

81 Les FPGAs Virtex 2 pro : les slices La cellule logique (slices)

82 Virtex 2 pro : détail du slice
Les FPGAs Le slice

83 CPLD ou FPGA ? CPLD et FPGA, pareil ?
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.

84 CPLD ou FPGA : configuration
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.

85 CPLD ou FPGA : routage Les FPGAs contiennent de larges ressources
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.

86 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.

87 CPLD ou FPGA : taille projet
vs FPFGA CPLD ou FPGA : taille projet Petit projet : SPLD ou CPLD Gros projet : FPGA

88 Synthèse : les SPLDs et sCPLD
vs FPFGA Synthèse : les SPLDs et sCPLD rétroactions entrées Réseau de ET Cellule I/O Pins reliées au réseau et aux cellules SPLD Pins et cellules à relier via des réseaux programmables d’interconnexion CPLD Configuration non volatile Cellules associées à un réseau commun de ET

89 Synthèse : les SPLDs et sCPLD
vs FPFGA Synthèse : les SPLDs et sCPLD Nombreuses petites cellules organisées matriciellement sans réseau de ET FPGA Configuration sur SRAM volatile

90 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)

91 SPLD DIP sur programmateur
Programmation des PLDs

92 SPLD CMS sur programmateur
Programmation des PLDs SPLD CMS sur programmateur

93 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.

94 Programmation in situ (ISP)
des PLDs Programmation in situ (ISP) Nécessité de prévoir sur le PCB le connecteur destiné au câble de configuration.

95 Principe de la programmation EPROM
des PLDs Principe de la programmation EPROM Principe du point de contact programmable : transistor N-MOS à grille « flottante » à injection de charge.

96 Cellule EPROM : structure
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.

97 Cellule EPROM : mise « off »
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.

98 Cellule EPROM : effacement
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.

99 Programmation des FPGA
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.

100 Programmation des FPGAs
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.

101 Exemple matériel : photo 1
Programmation des PLDs Exemple matériel : photo 1 Câble de configuration

102 Exemple matériel : photo 2
Programmation des PLDs Exemple matériel : photo 2 Oscillateur à quartz JTAG 2.5V SSRAM 3.3V FPGA EEPROM

103 Exemple matériel : photo 3
Programmation des PLDs Boîtier PQFP

104 Exemple matériel : photo 4
Programmation des PLDs Exemple matériel : photo 4 Boîtier TQFP DIP switch Boîtier PLCC

105 Schéma d’un système de configuration
Programmation des PLDs Schéma d’un système de configuration Les deux dispositifs peuvent être combinés EEPROM de configuration Connecteur JTAG de configuration Choix du mode

106 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.

107 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.

108 Système logique : définitions
p 2 1 e m 2 1 SYTEME LOGIQUE 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

109 Implémentation d’un système séquentiel
Etat futur Etat présent E Q * G M F Q S Entrées Variables Commande écriture Variables internes (Variables primaires) d'excitation (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.

110 Système séquentiel : fonctionnement
Implémentation d’un système séquentiel Système séquentiel : fonctionnement Etat futur Etat présent E Q * G M F Q 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).

111 Système séquentiel : horloge
Implémentation d’un système séquentiel Système séquentiel : horloge Etat futur Etat présent La commande d’écriture est généralement le front (montant ou descendant) d’un signal périodique appelé horloge. Q * Q M Horloge data1 data0 data2 data1 data3 data2 data4 data3 data5 data4 Horloge Q * Les changements d’état du bloc M sont dits synchrones de l’horloge.

112 Modèles : Moore ou Mealy
Implémentation d’un système séquentiel Modèles : Moore ou Mealy Etat futur Etat présent E Q * G F M Q S Horloge 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.

113 Cellule logique : système élémentaire 1 bit
Implémentation d’un système séquentiel Cellule logique : système élémentaire 1 bit Horloge D Strap ou Fonction combinatoire 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.

114 Implémentation d’un système n bits
séquentiel Implémentation d’un système n bits Horloge Bloc G Bloc M Bloc F combinatoire 1 D Q1 combinatoire 2 D Q2 Réseau du PLD 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.

115 Système n bits et combinatoire
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. combinatoire 1 Horloge Bloc G Bloc M combinatoire 2 combinatoire n D Réseau du PLD combinatoire F1 combinatoire F2 S1 S2 Bloc F 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

116 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

117 Compteur 4 bits : séquence d’états
Exercice: compteur synchrone 4 bits Compteur 4 bits : séquence d’états Q3 Q2 Q1 Q0 Cette table présente la succession désirée des états du compteur et donne la correspondance avec les labels attribués. S S S S S S S S S S S S S S S S Le passage d’un état au suivant sera provoqué par le front considéré actif de l’horloge.

118 Compteur 4 bits : tables des transitions
Exercice: compteur synchrone 4 bits Compteur 4 bits : tables des transitions S0 S1 S2 S3 S4 S5 S6 S7 S8 S9 S10 S11 S12 S13 S14 S15 État présent État futur D3 D2 D1 D0 Très simple ici : les états Di correspondent aux états futurs désirés Cette table permet d’établir les équations Di des bascules.

119 Compteur 4 bits : équations Di
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 = !Q0; D1 = Q1 $ Q0; D2 = Q2 $ (Q1 & Q0); D3 = Q3 $ (Q2 & Q1 & Q0);

120 Compteur 4 bits : validation
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 # S8 # S10 # S12 # S14)& VALID # Q0 & !VALID Terme de maintien D1 = (S1 # S2 # S5 # S6 # S9 # S10 # S13 # S14)& VALID # Q1 & !VALID D2 = (S3 # S4 # S5 # S6 # S11 # S12 # S13 # S14)& VALID # Q2 & !VALID D3 = (S7 # S8 # S9 # S10 # S11 # S12 # S13 # S14)& VALID # Q3 & !VALID

121 Activation et maintien conditionnés
Exercice: compteur synchrone 4 bits Activation et maintien conditionnés maintien rétroaction VALID D Q activation Excitation E CLK Horloge D = (E & VALID) # (Q & !VALID); activation maintien

122 Compteur synchrone : initialisation
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 # S10 # S12 # S14)& VALID # Q0 & !VALID)&!RAZ; D1 = ((S1 # S2 # S5 # S6 # S9 # S10 # S13 # S14)& VALID # Q1 & !VALID )&!RAZ; D2 = ((S3 # S4 # S5 # S6 # S11 # S12 # S13 # S14)& VALID # Q2 & !VALID )&!RAZ; D3 = ((S7 # S8 # S9 # S10 # S11 # S12 # S13 # S14)& VALID # Q3 & !VALID )&!RAZ; Cette initialisation sera du type SYNCHRONE

123 Remise à zéro synchrone
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;

124 Compteur synchrone : modulo
Exercice: compteur synchrone 4 bits Compteur synchrone : modulo On ajoute un modulo 10 programmable par le signal DIX. état présent état futur 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. D3 D2 D1 D0 S S1 S S2 S S3 S S4 S S5 S S6 S S7 S S8 S S9 S S10 S S11 S S12 S S13 S S14 S S15 S S0 On peut constater que seuls les bits D3 et D1 sont concernés par cette modification, ceci quand le compteur est à l ’état S9. S S0

125 Compteur modulo 10 : équations
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 # S10 # S12 # S14)& VALID # Q0 & !VALID)&!RAZ; D1 = ((S1 # S2 # S5 # S6 # S9&!DIX # S10 # S13 # S14)& VALID # Q1 & !VALID )&!RAZ; D2 = ((S3 # S4 # S5 # S6 # S11 # S12 # S13 # S14)& VALID # Q2 & !VALID )&!RAZ; D3 = ((S7 # S8 # S9&!DIX # S10 # S11 # S12 # S13 # S14)& VALID # Q3 & !VALID )&!RAZ;

126 Compteur : schéma structurel niveau PLD
Exercice: compteur synchrone 4 bits Compteur : schéma structurel niveau PLD RAZ VALID DIX q d 1 2 3 Q0 Q1 Q2 Q3 D0(RAZ,DIX,VALID,Q0,Q1,Q2,Q3) D1(RAZ,DIX,VALID,Q0,Q1,Q2,Q3) D2(RAZ,DIX,VALID,Q0,Q1,Q2,Q3) D3(RAZ,DIX,VALID,Q0,Q1,Q2,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.

127 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.

128 Généralisation des tables de transition
Variables externes État présent État futur M G État présent Variables externes 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

129 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

130 Structure générale d’une description
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.

131 Exemple : Compteur CPT en AHDL
Langages de description Exemple : Compteur CPT en AHDL CLOCK RAZ COMPTEUR CPT VALID 4 DIX 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.

132 Exemple : Compteur en AHDL (2)
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;

133 Exemple : Compteur en AHDL (3)
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

134 Primitive DFF de AHDL prn q d clk clrn
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 d clk q clrn prn compteur0 compteur0.q compteur0.d compteur0.clk compteur0.clrn

135 Usage de la primitive DFF
Langages de description Usage de la primitive DFF compteur[].prn prn q d compteur[].q compteur[].d compteur[] clk compteur[].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.

136 compteur[] = compteur[]+ 1; compteur[].d = compteur[].q + 1;
Langages de description Usage par défaut prn q d compteur[] compteur[] compteur[] clk compteur[].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.

137 AHDL : opérateurs arithmétiques
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 : >, <, >=, <=

138 AHDL : opérateurs logiques littéraux
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.

139 Équations structurées : if .. then .. else
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[]; Attention aux alternatives non explicitées, pour lesquelles les signaux concernés ne sont pas maintenus…

140 Alternative implicite de if
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...

141 Alternative implicite : cas des timers
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)

142 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 GRAFCET GRAPHSET 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.

143 GRAFCET Exemple de grafcet GRAFCET de bas niveau c1 1 A1 T=t1 ft1 2 A2 T=t2 c2.c3 c2.ft2 c2.c3 . 3 A3 4 A4 5 A5 T=t3 c4 1 ft3 6 A4 c5.c2 c1.c5 7 A3 8 A1 c6 c7 - entrées : c1, ft1, c2, ft2, c3, c4, c5, ft3, c6, c7 - sorties : A1, A2, A3, A4, A5 - nombre d'étapes : 9

144 Grafcet : principes de la formalisation
1 2 c1 étape c1 1 2 transition réceptivité Le système restera sur l’étape 1 tant que le front actif de l’horloge trouve la condition c1 fausse. c1 1 2 Ne pas représenter l’alternative à C1 : elle est implicite dans le grafcet.

145 Grafcet : chronogrammes d’une transition
Horloge C1 E1 E2 c1 E1 E2

146 Grafcet : transition synchrone
Attention aux implications du synchronisme : Horloge C1 c1 E1 E2 E1 E2 C’est l’état AVANT le front actif de l’horloge qui conditionne l’état suivant !

147 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.

148 Graphe d’état (ou diagramme d’état) Modèle de Moore 00,11 01,10
Alphabet d ’entrée : e1,e2 S0 S1 1 Alphabet de sortie : z XX 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.

149 Graphe d’état : exemple 1
S0 S1 00,11 01,10 Alphabet d ’entrée : e1,e2 Alphabet de sortie : z 1 XX 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

150 Graphe d’état : exemple 2
Compteur / décompteur modulo 4 : 4 états Entrées : up, init; Sorties : compteur[1..0]; X1 S0 10 1X 00 0X X1 S1 S3 1 3 00 00 10 10 S2 2 X : état indifférent

151 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

152 Implémentation One Hot Encoding
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

153 Mise en équations : exemple 1
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 : c1 E1 E2 c2 E3 E2 = E1 & C1 # E2 & !C2 ; Terme d ’activation Terme de maintien

154 Exemple 1 : commentaires
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.

155 Exemple 1 : variante IF E2 = E1 & C1 # E2 & !C2 ; if C1 then E2 = E1;
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.

156 Exemple 1 : Synthèse logique
Implémentation OHE Exemple 1 : Synthèse logique Maintien : E2 & !C2 C2 D Q C1 E2 Activation : E1 & C1 E1 CLK Horloge

157 Mise en équations : exemple 2
Implémentation OHE Mise en équations : exemple 2 c1 E1 E2 c2 E3 E4 c3 L’étape 2 est implémentée par une bascule D E2 dont l’excitation est régie par l’équation : E2 = E1 & C1 # E2 & ! (C2 # C3) ; 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.

158 Exemple 2 : remarque E2 = E1 & C1 # E2 & ! (C2 # C3) ;
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. c1 E1 E2 c2 E3 E4 c3 E2 = E1 & C1 # E2 & ! (C2 # C3) ; # E2 & ! (C2 # C3 # C4) ; 5 c4 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.

159 elsif not (C2 or C3 or C4) then E2 = E2; end if;
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;

160 Mise en équations : exemple 3
Implémentation OHE Mise en équations : exemple 3 c0 E2 c2 E3 c1 E1 E0 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

161 Mise en équations : exemple 4
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 : c1 E1 E2 1 E3 A E2 = E1 & C1; 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.

162 Exemple 4 : remarque A = E2; INTERDIT ! A = E1&c1;
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 ! c1 E1 E2 c2 E3 A L’action A aura pour équation : A = E2; Il ne faut surtout pas écrire : INTERDIT ! 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.

163 Mise en équations : exemple 5
Implémentation OHE Mise en équations : exemple 5 Cas de parallélisme : c1 E1 E2 1 c2 E3 E4 E5 E2 = E1&c1 # E2&!E4; E4 = E3&c2 # E4&!E2; E5 = E4&E2; 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.

164 Exercice de mise en équation
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.

165 Grafcet du transbordeur
Implémentation OHE Grafcet du transbordeur 1 2 3 4 5 6 7 Avance poussoir 1 Avance poussoir 2 Recul poussoir 2 Recul poussoir 1 pièce devant poussoir1 = dp1 pièce devant poussoir 2 = dp2 pièce évacuée = pe poussoir 1 en arrière = p1a poussoir 2 en arrière = p2a .

166 Equations du transbordeur
Implémentation OHE Equations du transbordeur Séquencement : E2 = (E1&dp1 # E2&!dp2)&!INIT; E3 = (E2&dp2 # E3&!pe)&!INIT; E4 = (E3&pe # E4&!p2a)&!INIT; E5 = (E4&p2a # E5&!E7)&!INIT; E6 = (E2&dp2 # E6&!p1a)&!INIT; E7 = (E6&p1a # E7&!E5)&!INIT; E1 = (E5&E7 # E1&!dp1 # INIT; Actions : avp1 = E2; avp2 = E3; rp1 = E6; rp2 = E4;

167 Transbordeur : initialisation
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 # E1&!dp1; E2 = E1&dp1 # E2&!dp2; E3 = E2&dp2 # E3&!pe; E4 = E3&pe # E4&!p2a; E5 = E4&p2a # E5&!E7; E6 = E2&dp2 # E6&!p1a; E7 = E6&p1a # E7&!E5; end if; (VCC = niveau 1 pour un bit ; GND = niveau 0 pour 1 bit )

168 Initialisation automatique
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;

169 Types d’action E1 c1 E2 c2 E3 c3 E1 E4 c1 E2 c2 E3 c3 E4
Implémentation OHE Types d’action c1 E1 E2 c2 E3 A c3 E4 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. Le signal A est un circuit combinatoire tel que A = E2 # E4;. c1 E1 E2 c2 E3 A=1 c3 E4 A=0 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.

170 Actions à mémoire : équations
Implémentation OHE Actions à mémoire : équations c1 E1 E2 c2 E3 A=1 c3 E4 A=0 A : DFF; … A.clk = clock; A = E2 # A&!E4; 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.

171 Comptage E0 C[3..0] : DFF; ... C[].clk = clock; C[] = (C[]+1)&(E1#E3)
Implémentation OHE Comptage E0 C=0 C[3..0] : DFF; ... C[].clk = clock; C[] = (C[]+1)&(E1#E3) # C[]&!E0; C[3..0] : DFF; … C[].clk = clock; C[] = ? c1 E1 C=C+1 c2 E2 # C[]&!(E0#E1#E3); c3 E3 C=C+1 Le comptage et le maintien doivent être exclusifs ! 1 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 !

172 Comptage : remarque sur le maintien
Implémentation OHE Comptage : remarque sur le maintien E0 C=0 C[] = (C[]+1)&E1 # C[]&!E0 c1 E1 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. C=C+1 c2 E2 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 C[] C[]+1 C[].d Etat futur

173 Comptage : activation et maintien
Implémentation OHE Comptage : activation et maintien C[] = (C[]+1)&E1 # C[]&!E0 D Q CLK E0=0 E1=1 C n + 1 Horloge C Une telle progression est symptomatique d’une non exclusion entre l’activation et le maintien !

174 Comptage : validation correcte
Implémentation OHE Comptage : validation correcte E0 C=0 c1 E1 L ’équation correcte du compteur C sera : C=C+1 c2 E2 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é…

175 Temporisation c1 E1 E2 tempo == N E3 tempo[15..0] : DFF; …
Implémentation OHE Temporisation L ’étape 2 valide l’incrémentation d’un compteur tempo par le signal en_tempo. c1 E1 E2 tempo == N E3 en_tempo 1 L ’étape 2 est maintenue tant que le compteur tempo n ’a pas atteint la valeur N. tempo[15..0] : DFF; … tempo[].clk = clock; tempo[].d = ? tempo[15..0] : DFF; … tempo[].clk = clock; 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...

176 Implémentation OHE Puits c1 1 2 c2 3 4 c3 Il peut arriver que l’on veuille exceptionnellement bloquer un système : pour on l’aiguille vers un « puits » E4 = E2&C3 # E4; D Q CLK E4 E2 C3 puits

177 Exercice : chronomètre
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.

178 Chronomètre : grafcet INIT START 1 2 RAZ STOP VALID Actions :
Implémentation OHE Chronomètre : grafcet INIT START 1 2 RAZ STOP VALID Actions : INIT : remise à zéro du compteur. VALID : validation du comptage

179 Chronomètre : équations
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 = E2&RAZ #E0&!START; E1 = (E0#E2)&START # E1&!STOP; E2 = E1&STOP # E2&!(START # RAZ); end if; E[].clk = CLOCK; if E[]==0 then E0.d = VCC; else E0.d = E2&RAZ #E0&!START; E1.d = E0&START # E1&!STOP; E2.d = E1&STOP # E2&!(START # RAZ); end if; L’équation de E1.d est fausse, pourquoi ?

180 Chronomètre : équations (2)
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;

181 Chronomètre : unités Expression structurée de UNIT[ ].d :
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[];

182 Chronomètre : dizaines
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[];

183 Exercice : Aiguillage Des bouteilles convoyées sur une file arrivent à
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.

184 Aiguillage : vue externe
Implémentation OHE Aiguillage : vue externe Ports d’entrée / sortie B V1 aiguillage V2 reset V3 clock Arrêt normal Arrêt urgence B : signal délivré par un capteur de passage de bouteille

185 Aiguillage : chronogrammes
Implémentation OHE Aiguillage : chronogrammes Bouteille V1 V2 V3

186 Aiguillage : ressources
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))

187 Aiguillage : schéma structurel
Implémentation OHE Aiguillage : schéma structurel aiguillage Compteur de Bouteilles Permutateur de Voies V1 V2 V3 CB clock reset Séquenceur B AN AU

188 Aiguillage : grafcet du séquenceur
Implémentation OHE Aiguillage : grafcet du séquenceur reset E0 E1 E2 E3 B 1 !B (CB!=5) &B CS_CB INIT_PV EN_CB (CB==5) &!(AN&V3) E4 E5 1 B EN_PV CS_CB

189 Aiguillage : grafcet du permutateur
Implémentation OHE Aiguillage : grafcet du permutateur V1 V2 V3 E4 Le permutateur est initialisé sur V1 par E0 E0 # E0

190 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.

191 Implémentation FSM : exemple
Détecteur d’états consécutifs z e Détecteur Horloge La sortie z passe à 1 si l ’entrée e est restée à 1 sur au moins 3 fronts d ’horloge consécutifs.

192 Détecteur : représentation
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 S0 S1 S2 S3 1 1 1 1 1

193 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.

194 Détecteur : codage sous forme de table
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;

195 Détecteur : codage par instruction CASE
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; when S3 => if !e then SS = S0; end if; end case;

196 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.

197 Détecteur : table des transitions
Implémentation FSM Détecteur : table des transitions Etat actuel Entrée e Etat futur B1.d B0.d S S S S S S S S S S S S S S S S 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;

198 Détecteur : équations réduites
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 ;

199 B0 = !B1&!B0&e # B1&!B0&e # B1&B0&e ;
Implémentation FSM D Q Clk e B0 B1 B1 = B1&!B0&e # B1&!B0&e # B1&B0&e ;

200 Exercice de synthèse : feux tricolores
Entrées : p1,p2 Sorties : V1,O1,R1 V2,O2,R2 P2 VOIE 2 P1 R1 V2 O2 R2 O1 V1 VOIE 1 Un détecteur de présence de voiture est placé sur chacune des voies, P1 pour la voie 1, P2 pour la voie 2.

201 Feux tricolores : spécifications
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.

202 Feux tricolores : spécifications
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.

203 Feux tricolores : graphe d ’état
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

204 Feux tricolores : graphe d ’état
Exercice de synthèse Feux tricolores : graphe d ’état 10 P1P2 S0 V1R2 00,11 S7 R1O2 S1 V1R2 01 10 S2 V1R2 S6 R1V2 S3 O1R2 S5 R1V2 S4 R1V2 00,11 01

205 Feux tricolores : table des transitions
Exercice de synthèse Feux tricolores : table des transitions table SS, P1,P2 => SS; S0, 1, 0 => S0; S0, 0, 0 => S1; S0, 1, 1 => S1; S0, 0, 1 => S3; S1, X, X => S2; S2, X, X => S3; table SS, P1,P2 => SS; S0, 1, 0 => S0; S0, 0, 0 => S1; S0, 1, 1 => S1; S0, 0, 1 => S3; S1, X, X => S2; S2, X, X => S3; S3, X, X => S4; S4, 0, 1 => S4; S4, 0, 0 => S5; S4, 1, 1 => S5; S4, 1, 0 => S7; S5, X, X => S6; S6, X, X => S7; S7, X, X => S0; end table; table SS, P1,P2 => SS; S0, 1, 0 => S0; S0, 0, 0 => S1; S0, 1, 1 => S1; S0, 0, 1 => S3; S1, X, X => S2; table SS, P1,P2 => SS; S0, 1, 0 => S0; S0, 0, 0 => S1; S0, 1, 1 => S1; S0, 0, 1 => S3; S1, X, X => S2; S2, X, X => S3; S3, X, X => S4; table SS, P1,P2 => SS; S0, 1, 0 => S0; S0, 0, 0 => S1; S0, 1, 1 => S1; S0, 0, 1 => S3; table SS, P1,P2 => SS; table SS, P1,P2 => SS; S0, 1, 0 => S0; table SS, P1,P2 => SS; S0, 1, 0 => S0; S0, 0, 0 => S1; table SS, P1,P2 => SS; S0, 1, 0 => S0; S0, 0, 0 => S1; S0, 1, 1 => S1;

206 Feux tricolores : sorties
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;

207 Feux : implémentation FSM
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.

208 Feux : ressources en mode FSM
Exercice de synthèse P1 P2 Q0 D0 = f0(P1,P2,Q0,Q1,Q2) Q1 D1 = f1(P1,P2,Q0,Q1,Q2) Q2 D2 = f2(P1,P2,Q0,Q1,Q2) V1 = g0(Q0,Q1,Q2) O1 = g1(Q0,Q1,Q2) R1 = g2(Q0,Q1,Q2) V2 = g3(Q0,Q1,Q2) O2 = g4(Q0,Q1,Q2) R2 = g6(Q0,Q1,Q2) V1 O1 R1 V2 O2 R2

209 Feux : implémentation OHE
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; V2 = S4#S5#S6; O1 = S3; O2 = S7; R1 = S4#S5#S6#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.

210 Implémentation : quelle méthode ?
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.

211 Grafcet et FSM : restriction
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 !

212 Système séquentiel structuré : exemple
Clavier 4x4 Compteur CA Compteur CE Commade alarme Décodeur clavier ALARME ETAT 8 TIMER Commade gacche RAZ GACHE OK CODE prédiv CLK DATAAV CA OK CE TIMER PROG SEQUENCEUR Les signaux de validations résultent ici implicitement du décodage du signal ETAT géré par le séquenceur

213 Un outil de développement : MAX+II

214 Max+II : Structure et entrées

215 Max+II : Flot d’un développement
Créer le PROJET .acf Text or schematic editor .tdf or .gdf Créer design (texte ou schéma) Compiler Compilation .snf fonctionnelle Waveform or vector editor Créer stimuli pour le test .scf or .vec (signaux ou vecteurs) Simulator Simuler .scf OK? Text or schematic editor Modifier le design Suite

216 Max+II : Flot d’un développement (2)
Suite Choix .acf device Compiler Compilation complète .rpt .pof OK? Floor plan editor Assignation .acf pins .rpt Recompilation Compiler .pof OK? Modifier design ou changer Choix système device de programmation Programmer Programmation Test OK? Modifier design Recette

217 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;

218 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[ ].

219 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.

220 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

221

222

223

224

225