Cours #4 Éléments à mémoire et circuits séquentiels synchrones de base

Présentation au sujet: "Cours #4 Éléments à mémoire et circuits séquentiels synchrones de base"— Transcription de la présentation:

1 Cours #4 Éléments à mémoire et circuits séquentiels synchrones de base

2 Un exemple pour commencer
Système de contrôle avec état. Système de contrôle sans état.

3 Circuits séquentiels synchrones
(notes, section 6.1) Circuits séquentiels synchrones Un circuit séquentiel comporte: une partie combinatoire; et des éléments à mémoire. Les éléments à mémoire entreposent l’état présent du circuit. La partie combinatoire calcule le prochain état du système ainsi que ses sorties. Un circuit séquentiel a normalement des entrées et des sorties. Un circuit séquentiel est mené par un signal d’horloge et devrait avoir un signal de réinitialisation. Ces signaux sont des entrées ‘spéciales’.

4 Circuits séquentiels synchrones
(notes, section 6.1) Circuits séquentiels synchrones Il y a deux types de circuits séquentiels : les circuits de Moore et de Mealy. Dans une machine de Moore, les sorties ne sont fonctions que de l’état présent. Dans une machine de Mealy, les sorties sont fonctions de l’état présent ainsi que des entrées.

5 Élément à mémoire – loquet SR
(notes, section 10.9) Élément à mémoire – loquet SR Un loquet SR (S-R latch) est un élément à mémoire simple mais fondamental. Il peut rester dans un état tant qu’on l’alimente, et sa sortie dépend non seulement des entrées présentes, mais aussi des entrées passées. S(t) R(t) Q(t) Q(t + 1) Q’(t + 1) mode 1 mémoire reset set interdit

6 Élément à mémoire – loquet D
(notes, section 10.9) Élément à mémoire – loquet D Le loquet D (D latch) est le type de loquet le plus commun. Il a deux entrées : un signal de données D; et, un signal de contrôle G (Gate). Il a deux états : transparent (quand G = 1); et, mémoire (quand G = 0). G(t) D(t) Q(t) Q(t + 1) mode mémoire 1 transparent

7 (notes, section 2.4) Loquet D: code VHDL Un loquet D peut-être modélisé en VHDL par un énoncé if-then à l’intérieur d’un processus. Le processus doit avoir dans sa liste de sensitivité le signal de contrôle G et le signal de donnée D. Le signal D est assigné à la sortie Q quand le signal de contrôle G est actif (mode transparent) library ieee; use ieee.std_logic_1164.all; entity loquetD is port ( G : in STD_LOGIC; -- contrôle D : in STD_LOGIC; -- donnée Q : out STD_LOGIC ); end loquetD; architecture loquetD of loquetD is begin process(G, D) is if (G = '1') then Q <= D; -- else -- implicite, infère élément à mémoire ne pas changer Q end if; end process; Patron de code spécial reconnu par les synthétiseurs pour signifier un loquet.

8 Exercice: un loquet ou pas?
(notes, section 4.5.6) Exercice: un loquet ou pas? library ieee; use ieee.std_logic_1164.all; entity mystere1 is port (a, b, c: in std_logic; s : in std_logic_vector (1 downto 0); o : out std_logic); end mystere1; architecture archi of mystere1 is Begin process (a, b, c, s) begin if (s = "00") then o <= a; elsif (s = "01") then o <= b; elsif (s = "10") then o <= c; end if; end process; end archi; library ieee; use ieee.std_logic_1164.all; entity mystere2 is port (a, b, c: in std_logic; s : in std_logic_vector (1 downto 0); o : out std_logic); end mystere2; architecture archi of mystere2 is Begin process (a, b, c, s) begin if (s = "00") then o <= a; elsif (s = "01") then o <= b; elsif (s = "10") then o <= c; else o <= c; end if; end process; end archi;

9 (notes, section 4.5.6) Un loquet ou pas? Les outils de synthèse reconnaissent des patrons de code spéciaux pour inférer des composantes matérielles correspondantes. La documentation d’un outil de synthèse spécifie quelle structure de langage utiliser pour obtenir le type d’élément à mémoire désiré. À l’intérieur d’un processus, un élément à mémoire est inféré en général si un objet des catégories signal ou variable se voit assigner une valeur dans un énoncé if-else et que certains cas ne sont pas couverts. Les cas non couverts impliquent que l’objet doit conserver sa valeur, et donc un loquet est inféré.

10 Test: chronogramme du loquet
(notes, section 10.9) Test: chronogramme du loquet Le loquet D a deux états : transparent (quand G = 1); et, mémoire (quand G = 0). library ieee; use ieee.std_logic_1164.all; entity loquetD is port ( G : in STD_LOGIC; -- contrôle D : in STD_LOGIC; -- donnée Q : out STD_LOGIC ); end loquetD; architecture loquetD of loquetD is begin process(G, D) is if (G = '1') then Q <= D; -- else -- implicite, infère élément à mémoire ne pas changer Q end if; end process;

11 Élément à mémoire – bascule D
(notes, section 10.9) Élément à mémoire – bascule D La bascule D (D flip-flop) est le type d’élément à mémoire le plus commun. Elle a deux entrées : un signal de données D; et, une horloge CLK (clock). L’entrée D est saisie sur une transition de l’horloge: soit de 0 à 1 (le cas par défaut) ou bien de 1 à 0 (indiqué par une bulle sur le signal CLK) Les changements sur D entre les transitions d’horloge sont sans effet.

12 Élément à mémoire – bascule D fonctionnement interne
(notes, section 10.9) Élément à mémoire – bascule D fonctionnement interne La bascule D peut être construite en cascadant deux loquets D avec des versions complémentaires d’un signal d’horloge.

13 (notes, section 2.4) Bascule D: code VHDL Pour modéliser une bascule, il est nécessaire de pouvoir décrire le fait que le changement d’état se produit sur une transition d’un signal d’horloge et non sur sa valeur. Pour ce faire, on peut utiliser les attributs d’événement (event attribute) définis en VHDL. L’Exemple démontre l’utilisation de l’attribut event sur le signal CLK, dénoté par CLK’event. La condition CLK = ‘1’ dénote alors un front montant. library ieee; use ieee.std_logic_1164.all; entity basculeD is port ( CLK : in STD_LOGIC; -- horloge D : in STD_LOGIC; -- entrée Q : out STD_LOGIC -- sortie ); end basculeD; architecture basculeD of basculeD is begin process(CLK) is if (CLK = '1' and CLK'event) then Q <= D; end if; end process; Patron de code spécial reconnu par les synthétiseurs pour signifier une bascule

14 Parenthèse: attributs en VHDL
(pas dans les notes) Parenthèse: attributs en VHDL En VHDL, les attributs permettent d’obtenir de l’information à propos de types, signaux, variables, etc. VHDL inclut des attributs prédéfinis, et on peut en définir de nouveaux. Quelques attributs prédéfinis utiles: Utilisation de l’attribut Résultat A’left, A’right Index le plus à gauche, le plus à droite du vecteur A A’low, A’high Index le plus bas, le plus haut du vecteur A A’range La gamme des index du vecteur A A’length Le nombre d’éléments du vecteur A T’left, T’right, T’low, T’high La valeur la plus à gauche, la plus à droite, la plus basse, la plus élevée du type T T’Image(x) La représentation textuelle de la valeur x dans le type T. T’Value(s) La valeur dans le type T de la chaîne de caractères s. S’event Vrai si un événement s’est produit sur le signal S.

15 Bascule D: code VHDL Spécification du front d’horloge désiré
(notes, section 2.4) Bascule D: code VHDL Spécification du front d’horloge désiré Le package std_logic_1164 contient aussi deux fonctions qui combinent ces conditions, rising_edge() et falling_edge(). Ces deux fonctions retournent des valeurs booléennes. Comportement désiré option 1 option 2 front montant CLK’event and CLK = ‘1’ rising_edge(CLK) front descendant CLK’event and CLK = ‘0’ falling_edge(CLK)

16 Exercice: donner le circuit correspondant à ce module
library IEEE; use IEEE.std_logic_1164.all; entity cctsequentielex4 is port ( clk, reset : in STD_LOGIC; A, B, C: in STD_LOGIC; U, V, W, X, Y, Z : out STD_LOGIC ); end cctsequentielex4; architecture arch of cctsequentielex4 is begin U <= CLK or reset; V <= A and B; process(CLK, reset) is if (reset = '0') then W <= '0'; X <= '1'; elsif (rising_edge(CLK)) then W <= A xor B; X <= not(B); end if; end process; process(A, C) is if (A = '0') then Y <= C nor B; Z <= not(B); else Z <= B nand C; end arch;

17 Bonne pratiques pour FPGAs
Utiliser des bascules: Les éléments à mémoire d’un FPGA peuvent implémenter une bascule ou un loquet. Il n’y a pas d’avantage à utiliser des loquets. Pour le reste du cours, nous allons utiliser exclusivement des bascules. Le signal d’horloge CLK est spécial: En principe, on mène toutes les bascules avec le même signal d’horloge CLK. On ne fait pas d’opérations logiques sur le signal CLK. Le signal de réinitialisation reset est spécial: Les circuits séquentiels doivent pouvoir être placés dans un état de départ connu. En principe, on mène toutes les bascules avec le même signal de réinitialisation. Certaines bascules peuvent être initialisées à ‘0’, d’autres à ‘1’. On ne fait pas d’opérations logiques sur le signal de réinitialisation.

18 Bascule D: code VHDL Deux types de signaux d’initialisation
(notes, section 2.4) Bascule D: code VHDL Deux types de signaux d’initialisation library IEEE; use IEEE.std_logic_1164.all; entity basculeDR is port ( reset : in STD_LOGIC; -- signal de remise à zéro CLK : in STD_LOGIC; -- signal d'horloge D : in STD_LOGIC; -- entrée Q : out STD_LOGIC -- sortie ); end basculeDR; architecture basculeDRasynch of basculeDR is begin process(CLK, reset) is if (reset = '0') then Q <= '0'; elsif (rising_edge(CLK)) then Q <= D; end if; end process; end basculeDRasynch; architecture basculeDRsynch of basculeDR is if (rising_edge(CLK)) then else end basculeDRsynch; Initialisation asynchrone: condition reset = ‘0’ à l’extérieur de la vérification du front d’horloge Initialisation synchrone: condition reset = ‘0’ à l’intérieur de la vérification du front d’horloge

19 Exercice: Compléter le chronogramme du circuit suivant
(notes, section 6.3) Exercice: Compléter le chronogramme du circuit suivant

20 Exercice: Décrire le circuit suivant en VHDL
(notes, section 6.3) Exercice: Décrire le circuit suivant en VHDL

21 (notes, section 6.3) Description d’un circuit séquentiel synchrone en VHDL à partir d’un schéma library IEEE; use IEEE.std_logic_1164.all; entity cctsequentielex1 is port ( reset : in STD_LOGIC; CLK : in STD_LOGIC; X : in STD_LOGIC; Z : out STD_LOGIC ); end cctsequentielex1; architecture arch1 of cctsequentielex1 is signal A : STD_LOGIC; -- bascule A signal B : STD_LOGIC; -- bascule B begin process(CLK, reset) is if (reset = '1') then A <= '0'; B <= '0'; elsif (rising_edge(CLK)) then A <= A xor B; B <= x or not(B); end if; end process; -- signal de sortie z <= not(A or B); end arch1; Un processus peut modéliser plusieurs bascules simultanément. Les signaux d’entrée des bascules peuvent être des expressions complexes. Les signaux qui ne sont pas mis en mémoire doivent être décrits séparément. Le signal d’initialisation n’est pas indiqué sur le schéma.

22 Réseaux pré-diffusés programmables (par l’utilisateur): Field-Programmable Gate Arrays (FPGA)
Un FPGA est composé à la base de : un réseau de blocs de logique programmable (Configurable Logic Block  CLB); un réseau d’interconnexions programmables entre les blocs; et, des blocs d’entrée et de sortie avec le monde extérieur (Input/Output Block – IOB). Ici: 12 IOBs, 3 × 5 CLBs XC5VLX50TFFG1136C: 480 IOBs, 120 × 30 CLBs

23 Virtex 5: tranche de type L (SLICEL)
Quatre tables de correspondance à 6 entrées: fonction logique mémoire ROM Quatre éléments à mémoire, bascule ou loquet. Des multiplexeurs pour router les signaux. Quelques portes logiques pour l’addition rapide. Xilinx inc., Virtex-5 FPGA User Guide (ug190 v. 5.4), March 2012

24 Bloc de logique programmable simplifié (~ une tranche du Virtex 2 Pro)
Deux tables de correspondance à 4 entrées: fonction logique mémoire RAM mémoire ROM décalage Deux éléments à mémoire, bascule ou loquet. Des multiplexeurs pour router les signaux.

25 Exercice: Implémenter le circuit suivant sur un FPGA

26 Compétences à avoir en INF3500 concernant les circuits séquentiels synchrones
Spécification textuelle Code VHDL Diagramme d’états Implémentation sur FPGA Schéma du circuit

27 Registre à chargement parallèle
(notes, section 5.4) Registre à chargement parallèle Un registre est l’élément à mémoire de base pour des données. Un registre est utilisé pour entreposer une information, encodée sur un groupe de bits, comme par exemple un octet de mémoire dans un ordinateur ou le contenu de l’accumulateur d’une calculatrice. Un registre est composé d’un groupe de bascules contrôlées par une horloge commune et dont les entrées et sorties partagent un identificateur commun. Chaque bascule du registre est différenciée des autres par un indice unique. Un registre à chargement parallèle comporte un signal de chargement qui permet de moduler le signal d’horloge. Quand ce signal est actif, le contenu du registre est modifié sur une transition de l’horloge. Dans le cas contraire, le contenu du registre reste inchangé.

28 Registre à chargement parallèle
(notes, section 5.4) Registre à chargement parallèle library IEEE; use IEEE.STD_LOGIC_1164.all; entity registre is generic ( W : integer := 8 ); port( reset : in STD_LOGIC; CLK : in STD_LOGIC; charge : in STD_LOGIC; D : in STD_LOGIC_VECTOR(W - 1 downto 0); Q : out STD_LOGIC_VECTOR(W - 1 downto 0) end registre; architecture arch of registre is Begin process (CLK, reset) begin if reset='0' then Q <= (others => '0'); elsif CLK='1' and CLK'event then if charge='1' then Q <= D; end if; end process; end arch;

29 Sommaire: modélisation d’un circuit séquentiel synchrone en VHDL
library IEEE; use IEEE.std_logic_1164.all; entity machineMooreMealy is port ( reset : in STD_LOGIC; CLK : in STD_LOGIC; entrees : in std_logic; sortiesMoore : out STD_LOGIC; sortiesMealy : out STD_LOGIC ); end machineMooreMealy; architecture arch of machineMooreMealy is signal etatpresent : std_logic; signal etatprochain : std_logic; begin -- éléments à mémoire process(CLK, reset) is if reset='0' then etatpresent <= '0'; elsif rising_edge(clk) then etatpresent <= etatprochain; end if; end process; -- calcul du prochain etat process(etatpresent, entrees) -- fonction de l'état présent et des entrées etatprochain <= etatpresent xor entrees; -- calcul des sorties de Moore process(etatpresent) -- fonction de l'état présent seulement sortiesMoore <= not(etatpresent); -- calcul des sorties de Mealy sortiesMealy <= etatpresent and entrees; end arch;

30 La vérification dans le flot de conception de circuits numériques
(notes, section 4.2) La vérification dans le flot de conception de circuits numériques

31 (notes, section 7.1) Vérification: rappel La vérification est un processus par lequel on vérifie qu’un design rencontre bien ses spécifications. La vérification complète d’un circuit est normalement un problème très difficile. Dans l’industrie de la conception numérique, on considère en général que le processus de vérification nécessite autant d’efforts que le processus de conception lui-même. La vérification d’un circuit est un art qui repose sur la maîtrise de trois principes: la compréhension de la spécification; le contrôle des entrées et de signaux internes du circuit à vérifier; et, l’observation des sorties, des signaux internes et de l’état du circuit à vérifier.

32 Vérification par banc d’essai
(notes, section 7.10) Vérification par banc d’essai Un banc d’essai permet d’appliquer des vecteurs de test à un circuit et d’observer sa sortie dans le but de vérifier qu’il rencontre ses spécifications. Un banc d’essai doit effectuer les tâches suivantes : instancier le circuit à vérifier; générer des vecteurs de test et les appliquer aux ports d’entrée du circuit; [utile]: générer automatiquement des réponses attendues aux vecteurs de test; [utile]: comparer les réponses du circuit aux réponses attendues, et indiquer toute différence entre les deux par une condition d’erreur. + (pour circuit séquentiel): générer un signal d’horloge et un signal de réinitialisation

33 Vérification par banc d’essai
(notes, section 7.10) Vérification par banc d’essai La génération d’un signal d’horloge périodique et d’un signal de réinitialisation peut être faite de façon très efficace par deux énoncés concurrents dans l’architecture du banc d’essai. L’horloge se voit assigner une valeur initiale dans sa déclaration, puis dans l’architecture elle bascule entre deux états à chaque demi-période. -- partie du banc d’essai -- dans la partie déclarative de l’architecture signal clk : std_logic := '0'; constant periode : time := 10 ns; ... -- dans l’architecture clk <= not clk after periode / 2; reset <= '0' after 0 ns, '1' after periode / 4;

34 Circuit séquentiel synchrone à vérifier
library IEEE; use IEEE.std_logic_1164.all; entity cctsequentielex1 is port ( reset : in STD_LOGIC; CLK : in STD_LOGIC; X : in STD_LOGIC; Z : out STD_LOGIC ); end cctsequentielex1; architecture arch1 of cctsequentielex1 is signal A : STD_LOGIC; -- bascule A signal B : STD_LOGIC; -- bascule B begin process(CLK, reset) is if (reset = '0') then A <= '0'; B <= '0'; elsif (rising_edge(CLK)) then A <= A xor B; B <= x or not(B); end if; end process; -- signal de sortie z <= not(A or B); end arch1;

35 Exemple de vérification d’un circuit séquentiel par banc d’essai
(notes, section 7.10) Exemple de vérification d’un circuit séquentiel par banc d’essai library ieee; use ieee.std_logic_1164.all; use std.textio.all; entity cctsequentielex1TB is end cctsequentielex1TB; architecture arch1a of cctsequentielex1TB is signal reset : std_logic := '0'; signal clk : std_logic := '0'; signal X : std_logic := 'X'; signal Z : std_logic := 'X'; constant periode : time := 10 ns; begin clk <= not clk after periode / 2; reset <= '0' after 0 ns, '1' after periode / 4; UUT : entity cctsequentielex1(arch1) port map (reset, clk, X, Z); process (clk) constant vecteurX : std_logic_vector := " "; variable compte : natural range 0 to vecteurX'length := 0; variable tampon : line; -- pointeur vers objet de type string if (falling_edge(clk)) then -- *** front différent de l'UUT *** write(tampon, "temps: "); write(tampon, now, unit => ns); write(tampon, ", x: " & std_logic'image(x)); write(tampon, ", z: " & std_logic'image(z)); write(tampon, ", compte: " & integer'image(compte)); writeline(output, tampon); -- écriture à la console if compte = vecteurX'length then report "simulation terminée" severity failure; else X <= vecteurX(compte); compte := compte + 1; end if; end process; end arch1a; Le processus est contrôlé par le signal d’horloge dans sa liste de sensitivité: pas d’énoncé wait. Les vecteurs de test sont encodés dans un tableau de constantes. Application du signal d’entrée sur un front différent d’horloge que celui de l’UUT. Pas de vérification automatisée des réponses dans cet exemple. Écriture formatée à la console à l’aide de procédures du package std.textio.all.

36 Comparaison avec un banc d’essai de circuit combinatoire
architecture arch2 of add3bitsTB is component add3bits -- déclaration du module à vérifier port (Cin, X, Y : in std_logic; Cout, S : out std_logic); end component; -- signaux pour les vecteurs de tests signal Cin, X, Y : std_logic; -- signaux pour les réponses signal Cout, S : std_logic; type tableauSLV3 is array (natural range <>) of std_logic_vector(2 downto 0); constant vecteurs : tableauSLV3 := ("000", "001", "010", "011", "100", "101", "110", "111"); begin -- instanciation du module à vérifier UUT : add3bits port map (Cin, X, Y, Cout, S); process -- application des vecteurs de test emmagasinés dans le tableau for k in vecteurs'low to vecteurs'high loop (Cin, Y, X) <= vecteurs(k); wait for 10 ns; end loop; end process; end arch2; La clause wait suspend l’exécution, force les signaux à se propager dans l’UUT, permet d’observer la réponse.

37 Parenthèse: Formatage de texte
(pas dans les notes) Parenthèse: Formatage de texte Écriture à la console avec la procédure writeline cible: objet output de catégorie file, défini dans le package textio source: objet de type line, défini dans le package textio Le type line est un pointeur (catégorie access) vers un objet de type string. Composition du message avec la procédure write. La procédure writeline libère le pointeur à la fin de son exécution. Formatage de texte avec l’attibut ‘image. process (clk) constant vecteurX : std_logic_vector := " "; variable compte : natural range 0 to vecteurX'length := 0; variable tampon : line; -- pointeur vers objet de type string begin if (falling_edge(clk)) then -- *** front différent de l'UUT *** write(tampon, "temps: "); write(tampon, now, unit => ns); write(tampon, ", x: " & std_logic'image(x)); write(tampon, ", z: " & std_logic'image(z)); write(tampon, ", compte: " & integer'image(compte)); writeline(output, tampon); -- écriture à la console if compte = vecteurX'length then report "simulation terminée" severity failure; else X <= vecteurX(compte); compte := compte + 1; end if; end process;

38 Parenthèse: Extrait du package TEXTIO
(pas dans les notes) Parenthèse: Extrait du package TEXTIO Texte complet disponible: package TEXTIO is type LINE is access STRING; -- A LINE is a pointer to a STRING value. type TEXT is file of STRING; -- A file of variable-length ASCII records. -- … type SIDE is (RIGHT, LEFT); -- For justifying output data within fields. subtype WIDTH is NATURAL; -- For specifying widths of output fields. file INPUT: TEXT open READ_MODE is "STD_INPUT"; file OUTPUT: TEXT open WRITE_MODE is "STD_OUTPUT"; procedure WRITELINE (file F: TEXT; L: inout LINE); procedure WRITE (L: inout LINE; VALUE: in BIT; JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0); procedure WRITE (L: inout LINE; VALUE: in BIT_VECTOR; JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0); procedure WRITE (L: inout LINE; VALUE: in BOOLEAN; JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0); procedure WRITE (L: inout LINE; VALUE: in CHARACTER; JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0); procedure WRITE (L: inout LINE; VALUE: in INTEGER; JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0); procedure WRITE (L: inout LINE; VALUE: in REAL; JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0; DIGITS: in NATURAL:= 0); procedure WRITE (L: inout LINE; VALUE: in STRING; JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0); procedure WRITE (L: inout LINE; VALUE: in TIME; JUSTIFIED: in SIDE:= RIGHT; FIELD: in WIDTH := 0; UNIT: in TIME:= ns); end TEXTIO; Le package inclut aussi des procédure read()

39 Parenthèse: Types physiques en VHDL
(pas dans les notes) Parenthèse: Types physiques en VHDL En VHDL, un type physique contient une valeur qui représente une mesure d’une quantité physique, comme le temps, la longueur, la tension ou le courant. Les valeurs de ce type sont exprimés comme des multiples entiers d’une unité de base. Les littéraux de types physiques sont exprimés par un entier ou une valeur à virgule flottante suivie d’une unité. La déclaration d’un type physique inclut: une gamme de valeurs exprimées dans l’unité de base l’unité de base des unités secondaires avec leur facteur multiplicatif entier de l’unité de base ou d’une autre unité secondaire déjà définie

40 Parenthèse: Déclaration du type physique time
(pas dans les notes) Parenthèse: Déclaration du type physique time Extrait du package STANDARD. Texte complet disponible: type TIME is range implementation_defined units fs; -- femtosecond ps = 1000 fs; -- picosecond ns = 1000 ps; -- nanosecond us = 1000 ns; -- microsecond ms = 1000 us; -- millisecond sec = 1000 ms; -- second min = 60 sec; -- minute hr = 60 min; -- hour end units; subtype DELAY_LENGTH is TIME range 0 fs to TIME'HIGH;

41 Modèle de producteur/consommateur
(pas dans les notes) Modèle de producteur/consommateur

42 Résumé: éléments à mémoire et circuits synchrones de base
Notions à retenir et maîtriser Importance relative 1. Énumérer les composantes et signaux qui distinguent un circuit séquentiel d’un circuit combinatoire; distinguer les circuits de Moore et de Mealy. 5 2. Expliquer le comportement temporel du loquet D et de la bascule D, et donner leur code VHDL. À partir d’un code VHDL, identifier les bascules et loquets. 15 3. Donner le code VHDL correspondant au schéma d’un circuit séquentiel, et donner le schéma d’un circuit séquentiel correspondant à un code VHDL. 25 4. Donner le chronogramme d’un circuit séquentiel décrit par un schéma ou du code VHDL. 5. Sur un diagramme de FPGA simplifié, montrer comment implémenter un module décrit en VHDL. 6. Composer un banc d’essai pour stimuler un modèle VHDL d’un circuit séquentiel. Donner le chronogramme résultant de l’exécution d’un banc d’essai. Total 100