I. INTRODUCTION - PRESENTATION

Transcription

1 Université Joseph Fourier Polytech 3i5 / Master 2 NENT Année I. INTRODUCTION - PRESENTATION Contexte - Conception des systèmes numériques Electronic design automation (EDA) is a category of software tools for designing electronic systems such as printed circuit boards and integrated circuits. The tools work together in a design flow that chip designers use to design and analyze entire semiconductor chips. EDA is also referred to as "Electronic Computer-Aided Design" (ECAD). Wikipedia Cours VHDL Laurence PIERRE (Laurence.Pierre@imag.fr) IP block: In electronic design a semiconductor intellectual property core, IP core, or IP block is a reusable unit of logic, cell, or chip layout design that is the intellectual property of one party. The IP core can be described as being for chip design what a library is for computer programming or a discrete integrated circuit component is for printed circuit board design. Synthesizable cores are delivered in a hardware description language such as Verilog or VHDL. COTS: Un composant pris sur étagère (commercial off-the-shelf ou COTS) désigne un composant fabriqué en grande série et non pour un projet en particulier. La conception et la mise au point d'un circuit digital (e.g., bloc IP), depuis son cahier des charges jusqu'à son ultime niveau de description, mettent 2

2 en oeuvre une panoplie de méthodes. o A partir d'une spécification informelle du système à construire, une formalisation à l'aide d'un langage ad hoc (langage spécialisé pour la description de systèmes matériels, comme VHDL, Verilog,...) pourra servir d'entrée aux divers outils offerts par un environnement de CAO de circuits. o Les outils de synthèse permettent de produire des descriptions du système de plus en plus concrètes, en vue de la réalisation matérielle. o A toutes les étapes, les simulateurs permettent une analyse du comportement du système, en fournissant des chronogrammes traduisant son évolution dans le temps suivant diverses séquences d'entrées. Nous étudierons les techniques utilisées lors de la spécification comportementale d'un système digital (en nous concentrant sur les systèmes de contrôle) et nous verrons comment réaliser la synthèse ASIC de cette spécification (sous forme d'une interconnexion de portes logiques et de registres), et nous évoquerons la synthèse FPGA. A ces deux niveaux de description (avant et après synthèse), des simulations peuvent être réalisées pour obtenir un certain niveau de confiance sur la bonne conception du circuit. Ces simulations peuvent aussi servir à vérifier l'équivalence des comportements avant et après synthèse. Chacun de ces niveaux de spécification peut être associé à une description dans le langage VHDL (une machine d'états est décrite en VHDL au niveau de description dit RTL, et un circuit synthétisé sous forme d'une interconnexion de portes logiques et de registres correspond à une description VHDL dite structurelle). Nous proposerons également une introduction à ces aspects du langage VHDL (standard IEEE 1076) et aux outils associés. Spécification Codage Validation Circuit Spécification comportementale Organisation : - 10 séances de cours VHDL Simulation + contraintes liées au matériel (fréquence, surface, consommation,...) - TP (au CIME-Nanotech - : o 3i5 : 4 séances de TP VHDL suivies de 3 séances de projet o NENT : 4 séances de TP VHDL 3 4

3 II. VHDL. ENTITES ET ARCHITECTURES II.1 Langages de description de matériel Les langages de description de matériel (Hardware Description Languages) ont vu le jour à la fin des années 1960, dans le but de décrire et simuler les circuits. Entre 1968 et 1975, il y a eu prolifération de langages (et simulateurs), couvrant divers niveaux d'abstraction. Une première tentative de standardisation a eu lieu à partir de 1973, avec le projet CONLAN (CONsensus LANguage). A l'heure actuelle, il existe deux standards IEEE : Verilog et VHDL. De façon générale, les langages de description de matériel peuvent offrir plusieurs des niveaux de description suivants : - algorithmique : modélisation de l'algorithme que le circuit doit réaliser - comportemental (ou système) : modélisation du comportement du circuit (automate, réseau de Pétri,...) - transfert de registres (RTL) : modélisation du circuit par des équations (qui expriment la mise à jour des registres) - portes logiques : modélisation comme une interconnexion de portes logiques (peut être hiérarchique : interconnexion de composants euxmêmes interconnexions de portes logiques) - transistors Verilog ( est né au début des années 1980 (Gateway Design Automation), avec le simulateur logique Verilog-XL. Il a été mis dans le domaine public en 1990 par Cadence (acquéreur de Gateway Design Automation), puis standardisé par l'ieee en 1995 (IEEE Std ). Il propose les niveaux de description algorithmique, RTL, portes logiques et transistors. Le développement de VHDL a été entrepris en 1981 par le Département de la Défense des USA (DoD), des industriels ont été largement impliqués dans le processus de standardisation. Le premier manuel de référence a été rédigé fin 1984, et les premiers outils ont été proposés en 1986 (vraiment disponibles en 1988). Il a été standardisé par l'ieee en 1987 (IEEE Std ), et des révisions significatives ont eu lieu en 1993, 2000 et Il propose les niveaux de description algorithmique, RTL et portes logiques. Remarque : Verilog-AMS et VHDL-AMS sont des dérivés de Verilog et VHDL, pour la description de systèmes à signaux analogiques et mixtes. II.2 VHDL - Premières notions VHDL signifie VHSIC (Very High Speed Integrated Circuits) Hardware Description Language. Sa sémantique est décrite en termes du moteur de simulation dirigée par événements, diverses constructions ne sont pas synthétisables. Nous étudions ci-dessous une partie de VHDL'87. Une description VHDL se compose d'une déclaration d'entité et d'une ou plusieurs architectures (généralement à différents niveaux d'abstraction). La déclaration d'entité décrit essentiellement l'interface (les ports d'entrée/sortie). Elle peut aussi spécifier des paramètres génériques qui permettent de modéliser des familles de circuits (paramètres de temps, taille des ports, nombre de composants utilisés, ). Sa forme, légèrement simplifiée, est la suivante : entity nom is generic (paramètres-génériques); port (ports d'entrées/sorties); déclarations diverses: types, constantes ; end nom; 5 6

4 Les ports d'entrées/sorties peuvent être spécifiés : - in : ports d'entrée, ne peuvent pas être modifiés - out : ports de sortie, ne peuvent pas être lus - inout : ports bidirectionnels, servant en entrée et en sortie - buffer : ports de sortie pouvant être lus Exemple : additionneur 1 bit entity full_adder is port(x,y,cin : in Bit; -- ports d'entrée Sum,Cout : out Bit); -- ports de sortie end full_adder; Les paramètres génériques peuvent être de n'importe quel type, avoir une valeur par défaut, et ils sont considérés comme des constantes. Exemples : entity Add_N_bit is generic(n: Natural); port(a,b: in Bit_vector(N downto 1); Cin: in Bit; S: out Bit_vector(N downto 1); Cout: out Bit); end Add_N_bit; entity async_transmitter is generic(bit_time: time := 20 ms); port(parallel_in: in bit_vector (7 downto 0); load: in bit; serial_out : out bit := '0'; done : out bit := '1'); end async_transmitter; Les architectures permettent de décrire le comportement ou la structure des composants représentés par les entités. Plusieurs architectures, éventuellement données à différents niveaux d'abstraction, peuvent être associées à une même entité. Trois styles de description peuvent être utilisés en VHDL : - le style "structurel" : interconnexion de composants, chacun d'eux étant une instance de couple entité/architecture - le style "dataflow" (s'apparente au niveau d'abstraction RTL) : ensemble d'instructions sur signaux qui décrivent les connexions entre portes logiques et les chargements de registres - le style "comportemental" : ensemble de processus qui expriment le comportement du système Une définition d'architecture a la forme suivante : architecture nom of nom-entité is déclarations instructions-concurrentes end nom; Dans la partie déclarations peuvent se trouver des déclarations de types, de constantes, de fonctions et procédures, de composants, et de signaux. On ne peut pas trouver de déclarations de variables (VHDL'87). Attention, Les instructions se trouvant dans une architecture sont toutes des instructions concurrentes. Dans le style structurel, on décrit une hiérarchie de composants interconnectés. Les communications se font par les interfaces (ports d'e/s), les interconnexions sont exprimées par les port map. Les composants utilisés doivent faire l'objet d'une configuration (voir plus bas). Exemple : architecture Structure_view of full_adder is -- déclaration des composants utilisés : component Half_adder port(i1,i2: in Bit; Carry,Sum: out Bit); 7 8

5 component Or_gate port(i1,i2: in Bit; O: out Bit); -- déclaration des "signaux" internes : signal A,B,C : Bit; U1: Half_adder port map(x,y,a,b); U2: Half_adder port map(cin,b,c,sum); U3: Or_gate port map(a,c,cout); end Structure_view; cin x y B A C sum cout Dans le style dataflow, la description traduit les équations caractéristiques du circuit, les temps de traversée des portes correspondant aux opérateurs utilisés peuvent être explicités. Exemple : cin x y S sum cout! II.3 Configurations Nous reviendrons plus loin sur l'instruction d'instanciation de composant, utilisée dans le style structurel. Voyons les configurations, qui permettent de spécifier les couples entités/architectures choisis pour instancier des composants. Une spécification de configuration peut être simplement placée dans l'architecture même. Elle a la forme suivante : for instance(s)_de_composant : nom_composant use entity nom_library.nom_entité(nom_architecture); De préférence, on fera appel à une unité de conception configuration, qui a la forme ci-dessous : configuration nom of nom_entité is for nom_arch for instance(s)_de_composant : nom_composant use entity nom_library.nom_entité(nom_architecture); end nom; architecture Dataflow_view of full_adder is signal S : Bit; -- pas indispensable ici S <= X xor Y after 5 ns; Sum <= S xor Cin after 5 ns; Cout <= (X and Y) or (S and Cin) after 20 ns; end Dataflow_view;! Cela est utile si l'on souhaite retarder le choix de configuration et/ou avoir plusieurs configurations pour une même architecture; nom_arch est généralement un nom d'architecture (mais peut être une étiquette de block ou de generate, voir plus loin). 9 10

6 Exemple : prenons le petit exemple illustratif ci-dessous A B 2ns S1 5ns S2 L'entité correspondante est la suivante : 4ns entity Exemple is port(a,b: in Bit; s: out Bit); end Exemple; Une description totalement dataflow ne nécessite pas de configuration : architecture RTL of Exemple is signal s1,s2: Bit; s1 <= not a after 2 ns; s2 <= s1 nand b after 5 ns; s <= s1 and s2 after 4 ns; end RTL; Voyons maintenant une description mixte structurelle/dataflow, avec configuration incorporée : entity porteet is port(x,y: in bit; s: out bit); end porteet; architecture RTL of porteet is s <= x and y after 4 ns; end RTL; entity portenand is port(x,y: in bit; s: out bit); end portenand; architecture RTL of portenand is s <= x nand y after 5 ns; end RTL; architecture Struct of Exemple is -- déclaration des composants utilisés : component porteet port(x,y: in bit; s: out bit); S component portenand port(x,y: in bit; s: out bit); -- configuration : for P1:porteET use entity work.porteet(rtl); for P2:porteNAND use entity work.portenand(rtl); -- déclaration des "signaux" internes : signal s1,s2: Bit; s1 <= not a after 2 ns; P1: porteet port map(s1, s2, s); P2: portenand port map(s1, b, s2); end Struct; Alternativement, une unité de conception spécifique peut être utilisée (il est d'ailleurs préférable de procéder ainsi) : architecture Struct of Exemple is component porteet port(x,y: in bit; s: out bit); component portenand port(x,y: in bit; s: out bit); signal s1,s2: Bit; s1 <= not a after 2 ns; P1: porteet port map(s1, s2, s); P2: portenand port map(s1, b, s2); end Struct; configuration Config1 of Exemple is for Struct -- pour l'architecture Struct de Exemple for P1: porteet use entity work.porteet(rtl); for P2: portenand use entity work.portenand(rtl); end Config1; Dans ce second cas, lorsqu'une instance de Exemple sera à son tour utilisée, la configuration mettra en jeu use configuration au lieu de use entity : 11 12

7 au lieu de for E:Exemple use configuration work.config1; for E:Exemple use entity work.exemple(struct); Remarque : les packages peuvent être utilisés pour rassembler des déclarations (types, constantes,...) et des définitions de sous-programmes. Les déclarations de composants peuvent également être placées dans un package, nous n'aborderons pas cette possibilité ici. 13