Il y a quelque années déjà (mai 2012) paraissait un article sur MIGEN dans Linux magazine. L’article est désormais disponible en ligne sur le site des éditions diamond.
Migen est un langage HDL basé sur Python et permettant de faire un design synchrone pour le FPGA.
Non non, vhd2vl n’est pas mort, contrairement à ce qui a été dit dans l’article de description du projet. Son auteur Larry Doolittle a publié une nouvelle version 2.5 l’été dernier (2015).
Et pour simplifier le développement collaboratif de ce programme un github a été ouvert. Comme il le dit sur sa page personnel du projet, Larry souhaite simplement intégrer son outils dans icarus (vhdlpp) de manière à pouvoir faire de la simulation VHDL avec. Mais pour faire une simple conversion VHDL->Verilog, vhd2vl est toujours d’actualité.
Un article sur le projet icestorm a été publié dans l’opensilicium numéro 17 de janvier-février-mars 2016.
Le code correspondant à l’article se trouve sur le github suivant.
Bonne lecture.
Fizzim est un petit logiciel graphique écrit en Java permettant de dessiner des machines d’états. Ce qui le différencie des autres logiciels de «dessin» c’est que Fizzim est capable de générer le code Verilog et/ou VHDL synthétisable correspondant.
Installation
L’archive est disponible sur le site officiel. Pour l’installer sous Linux, il suffit de la télécharger et de la dezziper dans le répertoire de son choix :
$ mkdir fizzim $ cd fizzim $ wget wget http://www.fizzim.com/mydownloads/fizzim_520.zip $ unzip fizzim_520.zip
La documentation est disponible sous la forme d’un pdf. C’est un programme écrit en java il faut donc lancer «l’executable» avec la machine virtuelle java :
$ java -jar fizzim_v14.02.26.jar
Fizzim enregistre ses projets avec un format *.fzm. Pour générer du code Verilog ou VHDL il faut utiliser le script perl fourni :
$ perl fizzim.pl < test.fzm > test.v
Pour le VHDL faire:
$ perl fizzim.pl -language VHDL < test.fzm > test.vhd
Un petit programme qui ne paye pas de mine mais qui est bien utile, surtout que le développement FPGA fait un usage intense des machines d’états.
Une présentation de Cocotb à la conférence ORCONF 2015 du CERN.
Quand on récupère un signal extérieur au fpga dont on ne maitrise pas le timing d’arrivée des fronts — typiquement un bouton ou une interruption — il est nécessaire de le synchroniser par rapport à l’horloge qui cadence le FPGA.
Il faut donc utiliser le montage classique des deux bascules. En Verilog et en VHDL cela se traduit par la déclaration d’un signal intermédiaire permettant la connection entre les deux bascules:
reg tmp, sig_s;
always @(posedge clk)
begin
tmp <= sig;
sig_s <= tmp;
end
Avec Chisel l’exemple donné dans le tutorial (page 14) est assez décevant car il impose aussi l’utilisation d’un signal intermédiaire :
s1 := signalA
s2 := s1;
signalB := s2
Pourtant il existe une méthode un peu plus élégante ne nécessitant qu’une seule ligne de code si on regarde du coté de la classe ChiselUtil : ShiftRegister()
Cette fonction permet de décaler un signal du nombre de coup d’horloge donné en argument, la synchronisation d’un signal par une double bascule n’étant rien de plus qu’un registre à décalage de deux coups d’horloge il suffit donc de l’utiliser avec un décalage de 2 :
val sig_s = ShiftRegister(sig, 2)
Si on regarde le Verilog généré par le backend on obtient bien les deux bascules souhaitées:
always @(posedge clk) begin
[...]
sig_s <= R23;
R23 <= sig;
[...]
end
Voila qui nous simplifie grandement les design, et évite l’empilement des copier/coller de signaux temporaire pour synchroniser des grappes de signaux.
Le jour du 27 mai 2015 sera à marquer d’une pierre blanche, en effet, c’est le jour où un FPGA a été libéré du joug des logiciels privateurs.
C’est le jour où Wolf Clifford a sorti une première version fonctionnelle du projet IceStorm permettant de synthétiser un design écrit en Verilog via Yosys et de faire le placement routage grâce à Arachne-pnr.
La conversion en bitstream et la programmation du chip se fait grâce aux utilitaires icepack et iceprog du projet IceStorm.
Pour l’instant le composant ciblé est le Lattice iCE40 HX1K-TQ144 pouvant être trouvé sur le kit d’évaluation lowcost (~$20) iCEstick.
Voici ci-dessous un petit howto rapide permettant de faire les manipulations se trouvant dans la vidéo de Clifford.
Icestorm howto
$ cd /opt $ git clone https://github.com/cliffordwolf/yosys.git $ yosys_deps="build-essential clang bison flex libreadline-dev gawk tcl-dev libffi-dev git mercurial graphviz xdot pkg-config python" $ sudo apt-get install $yosys_deps $ make config-gcc $ make $ make test $ sudo make install
$ sudo apt-get install libftdi-dev $ cd /opt/ $ mkdir icestorm $ wget http://www.clifford.at/icestorm/icestorm-snapshot-150526.zip $ unzip icestorm-snapshot-150526.zip $ make $ sudo make install
$ cd /opt/ $ git clone https://github.com/cseed/arachne-pnr.git $ make && sudo make install
Un exemple de «programme» est donné avec arachne-pnr dans le répertoire
example/rot. Cet exemple est composé du source en vérilog rot.v ainsi que du
placement des pin rot.pcf.
$ cd /opt/arachne-pnr/example/rot/ $ yosys -p "synth_ice40 -blif rot.blif" rot.v
$ arachne-pnr -d 1k -p rot.pcf rot.blif -o rot.txt
Le fichier généré rot.txt est la description finale du placement et du routage
du design dans le fpga. Cette description est parfaitement lisible en ascii
avec n’importe quel éditeur de texte.
Pour le télécharger dans le fpga nous devons le convertir en format binaire au
moyen de la commande «icepack» :
$ icepack rot.txt rot.bin
Nous avons un bitstream parfaitement compatible avec le ice40, il
nous faut maintenant le télécharger dans le fpga.
Et même pour cela, un logiciel libre est fourni : iceprog !
$ sudo iceprog rot.bin
On peut faire le tout en une seule ligne aussi si on veut :
yosys -p "synth_ice40 -blif rot.blif" rot.v;arachne-pnr -d 1k -p rot.pcf rot.blif -o rot.txt;icepack rot.txt rot.bin;sudo iceprog rot.bin
Et voila, bienvenue dans ce monde nouveau du FPGA libre !
Un language de description hardware basé sur Haskell permettant de simuler ses composants en Haskell pure. Permet aussi de générer le design synthétisable en VHDL.
Armadeus systems sort une nouvelle carte à base de processeur + FPGA au mois de février 2015: l’APF6_SP.
Armadeus systems s’est spécialisée dans les modules proc + fpga. Ils avaient déjà l’APF27 à base d’i.MX27 et de spartan3a ainsi que l’AFP51 à base d’i.MX51 et de spartan6. Ces deux cartes possèdent un lien de type bus mémoire avec le processeur de manière à ce que le FPGA soit vu dans sont espace mémoire de la même manière que les autres périphériques.
L’APF6_SP est toujours à base de processeur i.MX de chez Freescale : l’i.MX6. Ce processeur se décline en version solo, dual ou quad core. Une des particularité de cette nouvelle carte est qu’elle utilise un FPGA de chez Altera plutôt que Xilinx.
Deux gros changement interviennent avec cette nouvelle carte :
Mais pourquoi cette carte est-elle intéressante aux yeux du front de libération des FPGA ?
Car Armadeus Systems se base essentiellement sur des logiciels libres pour faire tourner ses modules. Le BSP est à base de buildroot, tous les outils de développement peuvent fonctionner sous Linux. Et pour le CycloneV, Quartus en version gratuite (web edition) sous Linux suffit.
Armadeus System joue la transparence avec une documentation abondante via un wiki et fournie tout son code sur sourceforge.
Enfin, un portage pour POD est en cours. Ce qui permettra d’utiliser un outils libre pour architecturer ses projets FPGA.
vhd2vl est un petit utilitaire écris en C (flex/bison) permettant de convertir du VHDL synthétisable en verilog. La page officiel présente la version 2.4, cette version ne compile qu’avec quelques modification sur une distribution récente.
Une version modifiée pour compiler sur debian jessie se trouve sur le github de Martoni. Pour l’utiliser il suffit de descendre le code avec git :
git clone git@github.com:Martoni/vhd2vl.git
Et faire un simple «make» dans le répertoire src/.
Pour convertir un fichier vhdl en verilog rien de plus simple (on pourra utiliser les exemples se trouvant dans les sources):
vhd2vl exemple.vhd > exemple.v
Le programme fonctionne plutôt bien à condition d’adapter son code vhdl de manière à générer un verilog correct.
En le testant sur mon «blinking led project» (blp), j’ai pu néanmoins constater quelques problèmes comme:
Bref vhd2vl est un petit logiciel comportant peu de fichiers sources : en fait juste deux. S’il ne répond pas tout à fait à nos attentes il est très facile d’aller le modifier pour l’adapter.
Après discussion avec Larry, visiblement la version 2.4 sera la dernière car l’objectif est de l’intégrer au projet icarus verilog. Mais j’ai beau compiler la dernière version du trunk de icarus, je ne parviens pas à faire la même chose avec.
[EDIT 7 janvier 2016] Non non, vhd2vl n’est pas mort, Larry continu a le développer.