FLASH INFORMATIQUE FI



public averti HDL_Draw, outil de conception de circuits numériques intégrés


Comment exploiter les modèles XSLT dans la conception des ASIC  et FPGA .



How to build ASIC’s and FPGA using XSLT language.


Jean SONGO PRISO


Introduction

Pensé et initié par le professeur Claude Magliocco, le projet HDL_Draw a été développé à l’Ecole d’ingénieurs et d’architectes de Fribourg par M. Jean Priso Songo, ingénieur ETS, avec la collaboration de M. Philippe Crausaz ingénieur EPFL pour les tests unitaires et fonctionnels. Le premier objectif du projet est la conception d’un compilateur simple et accessible des points de vue fonctionnel et financier, capable de générer du code HDL à partir d’un schéma électronique. Le produit à réaliser devra donc éviter la complexité des outils de développement classique, afin de focaliser l’attention de l’utilisateur sur son travail de conception. Le second objectif est la définition d’une méthodologie simple et efficace, qui permettra aux professeurs de disposer d’un outil didactique capable de les assister dans l’enseignement des circuits numériques intégrés.

Mais qu’est donc le VHDL ?

Le VHDL  a été développé dans les années 80 par le département américain de la défense, en vue de normaliser les langages de description matériel destinés à représenter le comportement ainsi que l’architecture d’un système électronique numérique. Les unités de conception primaires du langage correspondent à la vue externe des composants.


La spécification d’entité, très proche de la représentation symbolique du composant en schématique, définit les signaux d’entrées-sorties, leur type, ainsi que leur mode input, output, in-output, et les procédures qui y sont éventuellement associées. La généricité permet de paramétrer ces définitions. Ses unités de conception secondaires correspondent aux algorithmes des modèles et des sous-programmes. L’architecture est relative à une entité. Elle contient les fonctionnalités et éventuellement les relations temporelles du modèle, dans une description en vue de la synthèse. Cette définition est liée à la technologie. La description est une unité de conception primaire qui permet de créer un couple entité-architecture. Plusieurs architectures pouvant être associées à une entité.

Modéliser avant de réaliser, là est la réponse

Actuellement, tout concepteur de système électronique de puissance doit répondre à des contraintes industrielles et économiques très sévères. Afin de garantir le succès ou, dans une moindre mesure, réduire le risque d’erreurs dans des systèmes de plus en plus complexes, l’ingénieur doit faire appel aux méthodes de modélisation et de simulations. La modélisation permet de vérifier par simulation que le système en conception répondra au cahier des charges, mais elle permet aussi d’en optimiser les performances. Les langages de modélisation numériques sont des langages de description matérielle de haut niveau, communément appelés HDL. Le HDL prend en charge la description formelle d’un circuit logique, dans le but de concevoir des ASIC  et FPGA. Une modélisation efficace repose sur des outils performants, au mieux graphiques pour en faciliter l’usage, et peut se résumer en cinq étapes (voir tableau de la page suivante).

Etapes   Outils Commentaires
1. Description symbolique du circuit logique. Editeur graphique de schéma électronique Cette étape n’est pas indispensable mais facilite considérablement la compréhension du système et la lecture des modèles.
2. Description comportementale du circuit logique en langage VHDL. Editeur de texte Cette étape est l’une des plus consommatrice de ressources. Ici l’ingénieur écrit ligne après ligne le comportement de son modèle.
3. Traduction de la description VHDL en fonctions logiques. Outil de synthèse Le synthétiseur génère en sortie une liste d’interconnexion de composants logiques de base en fonction de la technologie choisie.
4. Routage. Routeur Le placeur-routeur crée à partir du fichier généré par le synthétiseur un fichier spécifique à la technologie cible qui décrit les connexions entre les composants élémentaires à disposition dans le circuit programmable.
5. L’intégration physique de la description. L’intégrateur L’intégration physique de la description est effectuée à partir de ce fichier spécifique dans le circuit programmable.

les cinq étapes pour une modélisation efficace

Pourquoi HDL-Draw ?

À la lumière des moyens à disposition de l’ingénieur pour assumer les contraintes techniques de ses projets, force est de constater que la mise en oeuvre de ces moyens serait vaine si leur exploitation industrielle s’avère non rentable. Parmi les outils de rentabilité d’un projet industriel, on peut citer :

  • la capitalisation des connaissances,
  • la réutilisation des modèles,
  • la modularité des systèmes,
  • l’automatisation ou l’industrialisation des processus répétitifs.

Tous ces moyens ont deux objectifs en commun : la réduction du temps de réalisation, c’est-à-dire le temps entre le cahier des charges et la fabrication du produit, et l’optimisation des ressources humaines et de sa formation. Ces deux objectifs restent de mise, quel que soit le milieu professionnel académique, ou industriel.
Puisqu’il faut assurer la rentabilité et optimiser le temps de formation, on peut imaginer qu’un outil qui prend en charge tout ou partie du travail à réaliser est d’un apport appréciable, tant pour l’ingénieur que pour le chef de projet.
C’est ce que va proposer HDL-Draw : générer automatiquement du code pour faire gagner du temps à l’ingénieur et à l’étudiant. HDL-Draw est donc conçu pour assister le concepteur là où il en a le plus besoin, à savoir les éditions de la schématique et du code VHDL résultant. Contrairement aux outils de référence dans le design des circuits intégrés, l’interface graphique de HDL-Draw est sobre et intuitive. On est loin de la complexité des produits propriétaires, certes plus élaborés, mais coûteux et peu adaptés à l’enseignement.


Le mode opératoire est simple. Un bouton permet à l’utilisateur de sélectionner le schéma électronique de son projet. Ensuite on transforme le schéma en un équivalent XML  à l’aide du bouton Générer le XML.
Le code VHDL est produit et affiché sur le navigateur Web par défaut de l’ordinateur en cliquant sur le bouton Générer le HDL.
Même si la portabilité vers d’autres plates-formes n’a pas été spécifiée, HDL_Draw pourrait aisément s’adapter pour fonctionner sous Linux. Pour cela, il suffira de coder l’interface en Java par exemple. La maintenance et l’intégration des futures options sont assurées en modifiant directement le modèle XSLT.

Réalisation

L’éditeur de schématique Dès les premières analyses du projet, il était clair qu’il ne serait pas possible de développer un éditeur de schéma dédié, et encore moins de s’appuyer sur un éditeur payant. Le projet s’est donc naturellement orienté vers les produits open source.
Plusieurs applications potentiellement aptes à satisfaire les exigences ont été testées : Inkscape, Dia, Sodipodi, toutes avec des avantages certains dont notamment le SVG qui est une description d’images vectorielles, codées en XML.
Le choix s’est finalement porté sur OpenOffice et plus précisément sur OpenDraw qui proposait de meilleurs atouts. En plus d’être libre, gratuit et multi-plateformes, l’application bénéficie d’un excellent support. Elle est facile à utiliser et jouit d’une bonne réputation dans la communauté estudiantine. Mais son meilleur atout est sa compatibilité ODF.
On verra plus loin comment cet avantage a orienté la suite du projet. ODF est l’acronyme de OpenDocumentFileformat, un dérivé du XML-Projet dont est issu le langage XML. Concrètement, cela signifie qu’un document OpenOffice, comme tout fichier compatible ODF, est transformable ou exportable en fichier XML.

Le modèle de données XML - HDL

XML est un langage qui sert essentiellement à stocker et à transférer des données de type texte structurées en champs arborescents.
Le modèle de données étant défini, la prochaine étape fut de typer chaque noeud XML et ses attributs à un objet HDL.

PNG - 12 ko
Modèle XML des objets HDL_Draw

Par exemple, chaque objet rectangle dans XML, représentera une entité HDL. Les attributs NomTitre et Description du noeud seront respectivement associés au nom, à l’architecture et au label de l’entité.

PNG - 14 ko
Représentation d’un Registre dans OpenDraw
<draw:rect draw:name="Registre" draw:layer="layout" svg:width="5.226cm" svg:height="7.023cm" svg:x="11.274cm" svg:y="3.477cm">
<svg:title>behave</svg:title>
 <svg:desc>reg1</svg:desc>
  <text:p text:style-name="P1"/>
  <text:p text:style-name="P1"/>
  <text:p text:style-name="P1">Registre</text:p>
</draw:rect>

Code XML résultant du Registre. On peut aisément identifier les valeurs saisies dans le schéma.

De XML à HDL

Les choix de l’éditeur et le modèle des données effectués, il reste encore à déterminer comment transformer les informations contenues dans le fichier XML en code VHDL. Une feuille de style scriptée en XSLT assurera cette fonctionnalité, tandis qu’un navigateur Web se chargera de compiler et d’afficher le résultat.

PNG - 14.2 ko
Schéma de principe
------------------------------------------------------------
--    Registre FOR Cmd_Pont
------------------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.numeric_std.all;

ENTITY Registre IS
PORT( );
END ENTITY Registre;

ARCHITECTURE behave OF Registre IS

BEGIN
Reg1: process( )
END behave;

Code VHDL résultant du schéma du registre

Sur le principe du registre présenté, s’en est suivi l’intégration des différents processus du VHDL, associés aux objets XML pré-typés. Ainsi, objet après objet, nous avons construit des machines d’états, intégré la notion de couche de schématique, traité les signaux internes, les entités génériques, le mapping des ports, etc. Il est aussi prévu des champs de saisie permettant au concepteur d’injecter directement du code HDL de description ou de déclaration dans l’entité de son choix. Cette fonctionnalité augmente considérablement la souplesse de l’outil dans des cas de conception actuellement non couverts par l’application. Les enseignants pourront aussi s’appuyer sur ce binôme objet symbolique/code résultant pour expliquer facilement lors des travaux pratiques la conception de divers composants et systèmes numériques.

Conclusion

À la fin de ce projet, force est de constater que tous les objectifs ont été atteints dans les délais. Certes il y a eu quelques doutes liés aux limites du langage XSLT et à l’usage des versions d’Internet Explorer inférieures à 6. Les deux problèmes ont été résolus en consultant un grand nombre d’ouvrages et en privilégiant le navigateur Opera. Pour information, il existe un plugin Microsoft qui permet aux anciennes versions d’Internet Explorer d’interpréter le XSL.
Il est à rappeler que la technologie privilégiée dans le développement de ce projet est une parmi d’autres aboutissant aux mêmes résultats, mais sans doute avec plus de complexité. On aurait pu par exemple imaginer l’usage d’une base de données pour stocker les noeuds XSL ou développer des librairies de composants dans le choix d’une programmation objet. Un workshop regroupant une douzaine de professeurs et collaborateurs de l’EIA-FR ainsi que des invités des autres HES-SO a été organisé au mois d’août. D’un point de vue général le produit a séduit par sa simplicité, son efficacité et son originalité. Cependant, quelques remarques portant à éprouver la saisie des schématiques ont été émises. Ces idées ainsi que quelques autres en cours de spécification seront intégrées dans la prochaine version de HDL_Draw.
Notre souhait est de créer une communauté autour de cet outil et, si possible, le promouvoir comme outil didactique de choix dans l’enseignement et la conception des circuits numériques intégrés. D’ores et déjà, quelques projets de l’Ecole, développés avec des produits commerciaux ont positivement migrés sous HDL_Draw.

PNG - 10 ko
Exemple d’une machine d’états réalisée avec HDL_Draw, schéma électronique (le code VHDL correspondant est visible co-après)
------------------------------------------------------------
--      QEI_M_etat M_ETAT
------------------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.numeric_std.all;
ENTITY QEI_M_etat IS
PORT(Enable_i:in std_logic;
A_i:in std_logic;
B_i:in std_logic;
clk_i:in std_logic;
reset_i:in std_logic;
Up_o:out std_logic;
Down_o:out std_logic;
Enable_Cnt_o:out std_logic
);
END ENTITY QEI_M_etat ;
ARCHITECTURE behave OF QEI_M_etat IS
 TYPE Etat_Type IS (Idle_State1,
Idle_State0,
Idle_State2,
Idle_State3,
Initialisation);
 SIGNAL Etat_Pres_s:Etat_Type;
 SIGNAL Etat_Fut_s:Etat_Type;
BEGIN
Fut: PROCESS(enable_i,A_i,B_i,Etat_Pres_s)
BEGIN
CASE Etat_Pres_s IS
                                                                                                 
WHEN Idle_State1 =>
   IF (Enable_i = '1' and
A_i = '1' and B_i = '1' ) THEN
         Etat_Fut_s <= Idle_State3;                                                         
   ELSIF (Enable_i = '1' and  A_i = '0' and B_i = '0') THEN
         Etat_Fut_s <= Idle_State0;                                                         
   ELSIF (Enable_i = '0') THEN
         Etat_Fut_s <= Initialisation;                                                
   ELSE
         Etat_Fut_s <= Idle_State1;
   END IF;
WHEN Idle_State0 =>
   IF (Enable_i = '1' and
A_i = '1' and B_i = '0' ) THEN
         Etat_Fut_s <= Idle_State1;                                                         
   ELSIF (Enable_i = '1' and A_i = '0' and B_i = '1' ) THEN
         Etat_Fut_s <= Idle_State2;                                                         
   ELSIF (Enable_i = '0') THEN
         Etat_Fut_s <= Initialisation;                                                
   ELSE
         Etat_Fut_s <= Idle_State0;
   END IF;
WHEN Idle_State2 =>
   IF (Enable_i = '1' and
A_i = '0' and B_i = '0' ) THEN
         Etat_Fut_s <= Idle_State0;                                                         
   ELSIF (Enable_i = '1' and  A_i = '1' and B_i = '1' ) THEN
         Etat_Fut_s <= Idle_State3;                                                         
   ELSIF (Enable_i = '0') THEN
         Etat_Fut_s <= Initialisation;                                                
   ELSE
         Etat_Fut_s <= Idle_State2;
   END IF;
WHEN Idle_State3 =>
   IF (Enable_i = '1' and
A_i = '0' and B_i = '1' ) THEN
         Etat_Fut_s <= Idle_State2;                                                         
   ELSIF (Enable_i = '1' and  A_i = '1' and B_i = '0' ) THEN
         Etat_Fut_s <= Idle_State1;                                                         
   ELSIF (Enable_i = '0') THEN
         Etat_Fut_s <= Initialisation;                                                
   ELSE
         Etat_Fut_s <= Idle_State3;
   END IF;
WHEN Initialisation =>
   IF (Enable_i = '1' and
A_i = '0' and B_i = '0' ) THEN
         Etat_Fut_s <= Idle_State0;                                                         
   ELSIF (Enable_i = '1' and
A_i = '1' and B_i = '0' ) THEN
         Etat_Fut_s <= Idle_State1;                                                         
   ELSIF (Enable_i = '1' and
A_i = '0' and B_i = '1' ) THEN
         Etat_Fut_s <= Idle_State2;                                                         
   ELSIF (Enable_i = '1' and
A_i = '1' and B_i = '1' ) THEN
         Etat_Fut_s <= Idle_State3;                                                
   ELSE
         Etat_Fut_s <= Initialisation;
   END IF;
 WHEN OTHERS =>
         Etat_Fut_s <= Idle_State1;
END CASE;
END PROCESS Fut;
Mem: PROCESS(clk_i, reset_i)
BEGIN
IF reset_i='1' THEN
         Etat_Pres_s <= Initialisation;
ELSIF rising_edge(clk_i) THEN
         Etat_Pres_s <= Etat_Fut_s;
END IF;
END PROCESS Mem;
Sorties: PROCESS(enable_i,A_i,B_i,Etat_Pres_s)
BEGIN
CASE Etat_Pres_s IS
WHEN Idle_State1 =>
               Enable_Cnt_o <= '0';
          Up_o <= '0'; Down_o <= '0' ;      
          if Enable_i = '1' then
           if A_i = '1' and B_i = '1' then
            Up_o <= '1'; Down_o <= '0';
            Enable_Cnt_o <= '1';
           elsif A_i = '0' and B_i = '0' then
            Up_o <= '0'; Down_o <= '1';
            Enable_Cnt_o <= '1';
           end if;
          end if;
WHEN Idle_State0 =>
              Enable_Cnt_o <= '0';
         Up_o <= '0'; Down_o <= '0';    
         if Enable_i = '1' then
           if A_i = '1' and B_i = '0' then
            Up_o <= '1'; Down_o <= '0';
            Enable_Cnt_o <= '1';
           elsif A_i = '0' and B_i = '1' then
            Up_o <= '0'; Down_o <= '1';
            Enable_Cnt_o <= '1';
           end if;
          end if;
WHEN Idle_State2 =>
               Enable_Cnt_o <= '0';
          Up_o <= '0'; Down_o <= '0' ;      
          if Enable_i = '1' then
           if A_i = '0' and B_i = '0' then
            Up_o <= '1'; Down_o <= '0';
            Enable_Cnt_o <= '1';
           elsif A_i = '1' and B_i = '1' then
            Up_o <= '0'; Down_o <= '1';
            Enable_Cnt_o <= '1';
           end if;
          end if;
WHEN Idle_State3 =>
               Enable_Cnt_o <= '0';
          Up_o <= '0'; Down_o <= '0' ;        
          if Enable_i = '1' then
           if A_i = '0' and B_i = '1' then
            Up_o <= '1'; Down_o <= '0';
            Enable_Cnt_o <= '1';
           elsif A_i = '1' and B_i = '0' then
            Up_o <= '0'; Down_o <= '1';
            Enable_Cnt_o <= '1';
           end if;
          end if;
WHEN Initialisation =>
    Up_o <= '0';
Down_o <= '0';
Enable_Cnt_o <= '0';         
WHEN OTHERS =>
   NULL;
END CASE;
END PROCESS Sorties;
END behave;

Mes remerciements vont en premier au professeur Claude Magliocco et à l’EIA-FR qui ont porté et partiellement financé ce projet pendant plus de six mois ; à Philippe Crausaz qui a activement participé à la réalisation des tests unitaires et fonctionnels ; et au professeur Omar Abou Khaled responsable des échanges internationaux à l’EIA-FR, pour la relecture et la publication de ce projet.

Bibliographie

  1. Claude Magliocco - EIA Fribourg, 2004. VHDL Synthétisable pour circuits numériques intégrés.
  2. Patrice Nouel - ENSEIRB Bordeaux, Langage VHDL et conception des circuits
  3. Etienne Messerli - HEIG Vaud, 2007. Manuel VHDL Synthèse et simulation
  4. Yannis Haralambous - ENST Bretagne, Maitriser XML et XSLT.
  5. Victor Stinner - 2005, Programmation avec XSLT


Glossaire

ASIC :
(Application Specific Integrated Circuits) : circuit intégré (micro-électronique) spécialisé.
FPGA :
(Field Programmable Gate Array) : réseau de portes programmables in situ.
HDL :
(Hardware Description Language) : langage informatique permettant la description d’un circuit électronique.
SVG :
(Scalable Vector Graphic) : format de données conçu pour décrire des ensembles de graphiques vectoriels et basé sur XML.
VHDL :
(Very high speed integrated circuit Hardware Description Language) : langage de description matériel destiné à représenter le comportement ainsi que l’architecture d’un système électronique numérique.
XML :
(eXtensible Markup Language) : langage informatique de balisage générique. Il sert essentiellement à stocker/transférer des données de type texte Unicode structurées en champs arborescents.
XSLT :
(eXtensible Stylesheet Language Transformations) : langage de transformation XML de type fonctionnel.


Cherchez ...

- dans tous les Flash informatique
(entre 1986 et 2001: seulement sur les titres et auteurs)
- par mot-clé

Avertissement

Cette page est un article d'une publication de l'EPFL.
Le contenu et certains liens ne sont peut-être plus d'actualité.

Responsabilité

Les articles n'engagent que leurs auteurs, sauf ceux qui concernent de façon évidente des prestations officielles (sous la responsabilité du DIT ou d'autres entités). Toute reproduction, même partielle, n'est autorisée qu'avec l'accord de la rédaction et des auteurs.


Archives sur clé USB

Le Flash informatique ne paraîtra plus. Le dernier numéro est daté de décembre 2013.

Taguage des articles

Depuis 2010, pour aider le lecteur, les articles sont taggués:
  •   tout public
    que vous soyiez utilisateur occasionnel du PC familial, ou bien simplement propriétaire d'un iPhone, lisez l'article marqué tout public, vous y apprendrez plein de choses qui vous permettront de mieux appréhender ces technologies qui envahissent votre quotidien
  •   public averti
    l'article parle de concepts techniques, mais à la portée de toute personne intéressée par les dessous des nouvelles technologies
  •   expert
    le sujet abordé n'intéresse que peu de lecteurs, mais ceux-là seront ravis d'approfondir un thème, d'en savoir plus sur un nouveau langage.