Quelles sont les meilleures pratiques pour les langues de description du matériel (Verilog, VHDL, etc.)
Quelles meilleures pratiques doivent être observées lors de la mise en œuvre du code HDL?
Quelles sont les points communs et différences par rapport aux champs de développement de logiciels plus courants?
Le meilleur livre sur ce sujet est Manuel de la méthodologie de réutilisation . Il couvre à la fois VHDL et Verilog.
Et en particulier certains problèmes qui n'ont pas de correspondance exacte dans les logiciels:
- Pas de loquets
- Soyez prudent avec des réinitialisations
- Vérifiez votre chronométrage interne et externe
- Utilisez uniquement du code synthétisable
- Enregistrez vos sorties de tous les modules
- Soyez prudent avec le blocage des missions non bloquantes
- Soyez prudent avec des listes sensibles pour la logique combinatoire (ou utilisez @ (*) dans Verilog)
Certains qui sont les mêmes incluent
- Utiliser cm
- Avoir des critiques de code
- Testez (simuler) votre code
- Réutiliser le code le cas échéant
- Avoir un horaire à jour
- Avoir une spécification ou des cas d'utilisation ou un client agile
HDL est comme Verilog et VHDL semblent vraiment encourager le code des spaghettis. La plupart des modules consistent en plusieurs blocs "toujours" (Verilog) ou "processus" (VHDL) qui peuvent être dans n'importe quel ordre. L'algorithme global ou la fonction du module est souvent totalement masqué. Découvrez comment fonctionne le code (si vous ne l'avez pas écrit) est un processus douloureux.
Il y a quelques années, je suis tombé sur ce document qui décrit une méthode plus structurée pour la conception VHDL. L'idée de base est que chaque module n'a que 2 blocs de processus. Un pour le code combinatoire et autre pour synchrones (les registres). C'est génial de produire du code lisible et maintenu.
en HDL, certaines parties du code peuvent fonctionner en même temps, par exemple deux lignes de code "peuvent fonctionner" en même temps, c'est un avantage, à utiliser judicieusement. C'est quelque chose qu'un programmeur habitué à la ligne par ligne des langues peut trouver difficile à saisir au début:
- De long et spécifique à vos besoins, des pipelines peuvent être créés.
- Vous pouvez faire fonctionner vos gros modules en même temps.
- au lieu d'une unité pour effectuer une action répétée sur différentes données, vous pouvez créer plusieurs unités et faire le travail en parallèle.
Une attention particulière doit être accordée au processus de démarrage - une fois que votre puce est fonctionnelle, vous avez fait une manière immense.
Le débogage sur le matériel est généralement beaucoup plus difficile que le logiciel de débogage afin:
Le code simple est préféré, il existe parfois d'autres moyens d'accélérer votre code, après avoir déjà fonctionné, par exemple en utilisant une puce de vitesse supérieure, etc..
Évitez les protocoles "intelligents" entre les composants.
Un code de travail en HDL est plus précieux que sur d'autres logiciels, car le matériel est si difficile à déboguer, alors réutilisez-vous et envisagez également d'utiliser des "bibliothèques" de modules que certains sont libres et d'autres personnes vendues.
la conception doit prendre en compte non seulement des bugs dans le code HDL, mais également des défaillances sur la puce que vous programmez et sur d'autres périphériques matériels interfaces avec la puce, il faut donc vraiment penser à une conception facile à vérifier.
Quelques conseils de débogage:
Si une conception comprend plusieurs blocs de construction, on voudrait probablement créer des lignes à partir des interfaces entre ces blocs pour tester des points à l'extérieur de la puce.
Vous voudrez enregistrer suffisamment de lignes dans votre conception pour détourner des données intéressantes à inspecter avec des périphériques externes. Vous pouvez également utiliser ces lignes et votre code comme moyen de vous indiquer l'état d'exécution actuel - par exemple si vous recevez des données à un moment donné, vous écrivez une certaine valeur sur les lignes, à un stade ultérieur d'exécution, vous écrivez une autre valeur. , etc'
Si votre puce est reconfigurable, cela deviendra encore plus pratique, car vous pouvez adapter des tests spécifiques et reprogrammer les sorties pour chaque test que vous allez (cela a très bien l'air avec les LED :). )
Edit:
Par protocoles intelligents, je voulais dire que deux de vos unités physiques se connectent, elles doivent communiquer avec le protocole de communication le plus simple disponible. C'est-à-dire que vous n'utilisez aucun protocole domestique sophistiqué, entre eux.
La raison, est-ce que cela - Fidning Bugs "à l'intérieur" Un FPGA/ASIC est relativement facile que vous avez des simulateurs. Donc, si vous êtes sûr que les données se présentent que vous le souhaitez, et sortez lorsque votre programme l'envoie, vous avez atteint le matériel utopia - être capable de travailler au niveau du logiciel :) (avec le simulateur). Mais si vos données ne vous arrivent pas, comme vous le souhaitez, et vous devez déterminer pourquoi ... vous devrez vous connecter aux lignes et que ce n'est pas si facile.
Trouver un bogue sur les lignes est difficile, car vous devez vous connecter aux lignes avec des équipements spéciaux, qui enregistrent les états des lignes, à des moments différents, et vous devez vous assurer que vos lignes agissent selon le protocole.
Si vous devez connecter deux de vos unités physiques, ce "protocole" aussi simple que possible, jusqu'à ce qu'il ne soit pas appelé un protocole :) Par exemple, si les unités partagent une horloge, ajoutez X lignes de données entre eux et faire une unité écrit celles-ci et l'autre unité de lecture, passant ainsi un "mot" qui a des bits X entre eux sur chaque horloge tombe, par exemple. Si vous avez des FPGA, si le taux d'horloge d'origine doit être trop rapide pour des données parallèles - vous pouvez contrôler la vitesse de ceci, selon vos expériences, par exemple, rendre les données restez sur des lignes de cycles d'horloge au moins "T", etc.. Je suppose que le transfert de données parallèle est plus simple, car vous pouvez travailler avec des fréquences d'horloge inférieures et obtenir les mêmes performances, sans avoir besoin de diviser vos mots sur une seule unité et de remonter sur l'autre. (Espérons que, il n'y a pas de retard entre "l'horloge", chaque unité reçoit). Même ceci est probablement trop complexe :)
En ce qui concerne SPI, I2C, etc. Je n'ai impliqué aucun d'entre eux, je peux dire que j'ai connecté les jambes de deux FPGA allant de la même horloge, (je ne me souviens pas de la formation exacte de résistances au milieu), à beaucoup des taux plus élevés, donc je ne peux vraiment pas penser à une bonne raison d'utiliser celles-ci, comme le moyen principal de transmettre des données entre vos propres FPGA, à moins que les FPGA ne soient situés très loin d'un autre, ce qui est une raison pour utiliser une série plutôt qu'un bus parallèle.
JTAG est utilisé par certaines entreprises FPGA, pour tester/programmer leurs produits, mais pas sûr s'il est utilisé comme moyen de transporter des données à grande vitesse, et c'est Un protocole ... (toujours celui qui peut avoir un support intégré sur puce).
Si vous devez mettre en œuvre un protocole connu, envisagez d'utiliser un code HDL pré-établi pour cela - qui peut être trouvé ou acheté.
C'est la question qui nécessite les 10 commandements de JBDavid pour la conception matérielle.
- Utilisez le contrôle de révision/de version, tout comme dans le logiciel. SVN et HG sont gratuits.
- Exiger que le code passe la vérification de la syntaxe avant l'enregistrement. Un outil de peluche est meilleur.
- Utilisez une langue de vérification matérielle à pleine force pour la vérification de la conception. System-Verilog est presque un choix sûr.
- Punaises de piste. Bugzilla et Gnats sont des outils gratuits. Fogbugz nécessite un petit $.
- Utilisez des assertions pour attraper des problèmes avec une utilisation incorrecte.
- La triade de couverture effectue une conception stable: mesurez la couverture de code, la couverture fonctionnelle et la couverture d'affirmation dans les outils de simulation et d'outils formels.
- Le pouvoir est roi: utilisez CPF ou UPF pour capturer, appliquer et vérifier votre intention de pouvoir.
- le design réel est souvent un signal mixte, utilisez un langage de signal mixte pour vérifier l'analogique avec le numérique. Verilog-AMS est une de ces solutions. Mais ne va pas trop loin. La modélisation de réaction peut accomplir la plupart des aspects fonctionnels du comportement de signal mixte.
- Utilisez l'accélération matérielle pour valider le logiciel qui doit fonctionner avec le silicium!
- Syntaxe CADIRE Les éditeurs de texte pour votre HDL/HVL sont une exigence minimale pour le développeur IDE.
Pour les FPGA, Xilinx a cette page . Presque tous s'appliqueraient aux autres fournisseurs de FPGA ou auraient des règles équivalentes. Une bonne affaire est applicable à ASIC Designs.
Intel a recommandé des styles de codage HDL et des recommandations de conception (PDF) sous cette page .