à la logique programmable Initiation à la logique programmable

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)

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

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é

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 à 10000 portes 1000 à x1000 000 portes

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

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

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

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…

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

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.

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

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.

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

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

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

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

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

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.

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

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

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

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

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

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

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 1 0 0 0 0 S2 X X X X X X 1 0 0 0 0 1 S3 X X X X X 1 0 0 0 0 1 0 S4 X X X X 1 0 0 0 0 0 1 1 S5 X X X 1 0 0 0 0 0 1 0 0 S6 X X 1 0 0 0 0 0 0 1 0 1 S7 X 1 0 0 0 0 0 0 0 1 1 0 S8 1 0 0 0 0 0 0 0 0 1 1 1 S9 0 0 0 0 0 0 0 0 1 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.

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;

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

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 :

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 0000 0 1 1 0011 1111 0100 0000 1 0 1 0110 1111 0111 0000 0111 1011 0111 1100 1 1 0 1111 1111 0000->3fff plage0 4000->6fff 7000->7bff plage1 7c00->ffff plage2 Les 6 bits de poids fort suffisent pour ce décodeur

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;

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;

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

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

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

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.

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

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.

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.

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.

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.

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.

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;

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.

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.

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

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

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

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.

(« 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

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

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.

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

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.

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.

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

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

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

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)

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

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

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 !

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

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

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.

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

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)

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

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

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

Les FPGAs XC4000 : Bloc E/S

XC4000 : exemple de routage Les FPGAs

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.

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

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

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

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

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

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

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

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

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

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.

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.

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.

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.

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

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

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

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)

SPLD DIP sur programmateur Programmation des PLDs

SPLD CMS sur programmateur Programmation des PLDs SPLD CMS sur programmateur

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.

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.

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.

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.

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.

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.

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.

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.

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

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

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

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

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

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.

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.

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

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.

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

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.

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.

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.

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.

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

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

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. S0 0 0 0 0 S1 0 0 0 1 S2 0 0 1 0 S3 0 0 1 1 S4 0 1 0 0 S5 0 1 0 1 S6 0 1 1 0 S7 0 1 1 1 S8 1 0 0 0 S9 1 0 0 1 S10 1 0 1 0 S11 1 0 1 1 S12 1 1 0 0 S13 1 1 0 1 S14 1 1 1 0 S15 1 1 1 1 Le passage d’un état au suivant sera provoqué par le front considéré actif de l’horloge.

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 0 0 0 1 0 0 1 0 0 0 1 1 0 1 0 0 0 1 0 1 0 1 1 0 0 1 1 1 1 0 0 0 1 0 0 1 1 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 1 0 1 1 1 1 0 0 0 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.

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

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

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

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

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;

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 0 0 0 1 S0 S1 S1 S2 S2 S3 S3 S4 S4 S5 S5 S6 S6 S7 S7 S8 S8 S9 S9 S10 S10 S11 S11 S12 S12 S13 S13 S14 S14 S15 S15 S0 0 0 1 0 0 0 1 1 0 1 0 0 0 1 0 1 0 1 1 0 0 1 1 1 1 0 0 0 1 0 0 1 1 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 1 0 1 1 1 1 0 0 0 0 On peut constater que seuls les bits D3 et D1 sont concernés par cette modification, ceci quand le compteur est à l ’état S9. 0 0 0 0 S9 S0

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;

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.

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.

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

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

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.

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.

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;

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

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

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.

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.

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 : >, <, >=, <=

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.

É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…

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

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)

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.

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

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.

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

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 !

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.

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.

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

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

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

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

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

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.

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.

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

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.

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.

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;

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

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.

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.

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.

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.

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 .

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;

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 )

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;

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.

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.

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 !

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 0 0000 0001 0001 1 1 0001 0010 0011 3 3 0011 0100 0111 7 7 0111 1000 1111 15

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 0 1 3 7 15 31 63 Une telle progression est symptomatique d’une non exclusion entre l’activation et le maintien !

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é…

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

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

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.

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

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 ?

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;

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[];

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[];

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.

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

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

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

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

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

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

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.

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.

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

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.

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;

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;

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.

Détecteur : table des transitions Implémentation FSM Détecteur : table des transitions Etat actuel Entrée e Etat futur B1.d B0.d S0 0 S0 0 0 S0 1 S1 0 1 S1 0 S0 0 0 S1 1 S2 1 0 S2 0 S0 0 0 S2 1 S3 1 1 S3 0 S0 0 0 S3 1 S3 1 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;

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 ;

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 ;

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.

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.

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.

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

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

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;

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;

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.

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

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.

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.

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 !

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

Un outil de développement : MAX+II

Max+II : Structure et entrées

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

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

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;

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

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.

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