Génération d'un transcodeur VHDL ASCII vers binaire à l'aide de Matlab

Comme précedement pour le transcodeur Binaire-BCD, on peut utiliser Matlab pour générer du code en VHDL.

Explication détaillée en anglais ici.

Le script Matlab :

FileID = fopen('transcoderASCII2Binary.h','w');

fprintf(FileID, '\t\tcase char is\n');

for i=32:127
fprintf(FileID, '\t\t when ''%s''=> \n\t\t\t data <= "%s"; \n',char(i), dec2bin(i,8)); end fprintf(FileID, '\t\t when others => \n\t\t\t data <= "00000000"; \n'); fprintf(FileID, 'end case;'); fclose(FileID);

Le résultat :

case char is
when ' '=>
data <= "00100000";
when '!'=>
data <= "00100001";
when '"'=>
data <= "00100010";
when '#'=>
data <= "00100011";
when '$'=>
data <= "00100100";
[............]
when '~'=>
data <= "01111110";
when ''=>
data <= "01111111";
when others =>
data <= "00000000";
end case;

Réalisation d'un transcodeur binaire-BCD 8 bit :

Afin d'exploiter pleinement les deux afficheurs 7-segments de la carte de développement FPGA, j'ai besoin d'un décodeur binaire-BCD 8 bit. Couplé à un convertisseur "BCD to 7seg" du type 74248, il me permettra d'afficher des nombres décimaux allant de 00 à 99 en utilisant les deux digits.

Dans un premier temps j'ai cherché bloc tout-fait mais la bibliothèque max-plus d'Altera n'offre que des convertisseurs acceptant des binaires sur 5 bit (par exemple le 74185).

L'idéal était donc de le créer mon propre bloc et l'ajouter dans le design. En BCD les 4 bits de poids faible codent les unitées etque les 4 bits de poids fort codent les unités. L'algorithme à suivre pour réaliser la conversion est donc assez simple :

- convertir le nombre binaire entrant en entier,
- faire la division euclidienne par 10,
- convertir le reste et le résultat en binaire sur 4 bits,
- sortir le résultat d'un coté et le reste de l'autre.

En fait pour simplifier le code VHDL du bloc, on va réaliser une table de comparaison à l'aide d'une structure du type "case" :

case (nb_binaire) is
when "00000000"=>
nb_BCD1 <= "0000"; nb_BCD2 <= "0000"; when "00000001"=>
nb_BCD1 <= "0001"; nb_BCD2 <= "0000";

.....

Le code est très répétitif il peut donc être généré en partie par Matlab à l'aide du script suivant :

FileID = fopen('transcodeur.vhdl','w');
x=0;
for i=0:100
resultat=floor(x./10);
reste=mod(x,10);
fprintf(FileID, 'when "%s"=> \n\t nb_BCD1 <= "%s"; \n',dec2bin(x,8), dec2bin(reste,4));
fprintf(FileID, '\t nb_BCD2 <= "%s"; \n\n',dec2bin(resultat,4));
x=x+1;
end

fclose(FileID);

Une fois le code généré on crée un nouveau bloc (.bsf) dans Quartus et on l'ajoute au design existant (ici le bloc transcodeur.vhdl est ajouté dans le bloc dédié à l'affichage).

Utilisation des DACs de la carte de developpement STRATIX DSP

Le projet : Réaliser un banc de test mémoire permettant de mesurer différentes caractéristiques d'une mémoire (tension minmale d'alimentation, consommation, temps d'accès, etc...). Le système est implémenté sur une carte de développement FPGA : "STRATIX DSP DevKit ALTERA".

Le carte de dévelopemmet STRATIX DSP dispose de deux convertisseurs numériques analogiques. Pour les utiliser, il faut connecter les sorties du FPGA aux entrée logiques du convertisseur et également lui communiquer une horloge. Pour démarrer, nous allons réaliser un bloc commandé par les switchs DIP qui permet d'envoyer différents vecteurs sur les entrées de commande des CNAs :

Le combinaison des 4 switch d'entrée va nous permettre de choisir le vecteur de commande appliqué sur les broches du DAC.

Les pins correspondant aux différentes broches du DAC sont données dans la datasheet de la carte dans le rubrique "D/A Converters" (PIN_A21..PIN_B19) :

Il suffit donc de connecter les sorties du schéma bloc aux pins adéquates à l'aide de l' "Assignement Editor" (cf prise en main de QuartusII ). Pour communiquer le signal d'horloge, plusieurs solutions sont possibles : utiliser une PLL interne, récupérer le signal de l'oscillateur présent sur le carte (80 Mhz) et le transmettre à la broche de l'horloge du DAC (pour D/A1, PIN_AE15), [Remarque : il est parfois possible de cabler directement sur la carte l'oscillateur sur la broche d'horloge du convertisseur à l'aide des cavaliers. Ce n'est pas le cas pour les DAC sur cette carte.] Dans notre cas, une horloge interne (dérivée de l'ocsillateur externe) est déjà présente dans le système. On connectera donc cette horloge à la broche "clk" du DAC.

Commande d'une alimentation par DAC08C

Le projet : Réaliser un banc de test mémoire permettant de mesurer différentes caractéristiques d'une mémoire (tension minmale d'alimentation, consommation, temps d'accès, etc...). Le système est implémenté sur une carte de développement FPGA : "STRATIX DSP DevKit ALTERA".

Afin de sérialiser les tests, on se doit d'automatiser l'alimentation de la mémoire et commander la tension par l'intermédiare du système embarqué sur le FPGA.





La solution retenue consiste à commander des convertisseurs numériques/analogiques. Dans un premier temps j'ai cherché à utiliser un composant externe à la carte de developpement FPGA (un DAC 08C) en connectant des sorties logique aux entrées de contrôle (B1 à B8).
La carte dispose déjà de convertisseurs numériques/analogiques mais ce montage pourrait être retenu dans le cas ou l'on souhaiterait réaliser une carte de développement et se passer des périphériques présent sur la carte de développement ALTERA

Le shéma utlisé est le suivant :

Ce montage permet d'obtenir une tension de référence, mais il ne permet pas de fournir une centaine de mA et d'alimenter directement la mémoire. On doit amplifier le courant de sortie et effectuer une adaptation d'impédance. Pour cela on peut utiliser un montage à base d'un AOP ou de transistors NPN.

.

Exploitation d'un flux XML avec OpenLaszlo

OpenLaszlo est un superbe outil qui vous permet de générer des applications AJAX en Flash ou DHTML à partir d'une grammaire particulière assez simple d'accès basée sur XML (chaque code est encadré par "canvas" "/canvas" et est enregisté dans un fichier ".lzx". Les fichiers .lzx exécutés par le server (Tomcat/OpenLaszlo) sont visualisable par n'importe quel navigateur web compatible Flash ou DHTML.

RSS et ATOM sont des technologies que j'utilise tous les jours via Netvibes, mais que je ne connais pas en détail. Je vais donc esseyer de réaliser un mini-lecteur de flux RSS (très rudimentaire dans un premier temps) à l'aide de OpnLsz. Première étape préciser à OpnLsz quel fichier on utilise (ici le flux atom du blog de Freddy Mini, qui travaille chez... Netvibes !! ;) ) :

" dataset name="flux" src="emini_blog.xml"/ " la balise " dataset .../ "

permet d'assoncier un "name" et un chemin "src". Ici le ficher est en local sur le serveur mais on peut imaginer mettre une adresse http://www.etc.. Ensuite on organise les données de façon sommaire : En précisant OpnLszo va directement sérialiser l'affichage des items. Inutile de faire de boucle "for". On récupère ici les informations portant sur :
- la date de publication,
- le titre,
- le contenu du post.

Le résultat obtenu mérite d'être remis en forme. On peut commencer par mettre l'ensemble dans un fenêtre à l'aide des balise " window " et " /window ". L'imbrication des " view " permttra d'afficher le résultat proprement en évitant les problèmes de superposition des éléments (les éléments déclarés les derniers sont au dessus et réciproquement).

<code>
<canvas>
<dataset name="flux"
request="true" type="http"
src="http://feeds.feedburner.com/emini_blog"/>
<view id="main">
<window id="content" width="950" height="450" x="10" y="10" resizable="true" title="Flux">
<view>
<simplelayout axis="y"/>
<view datapath="flux:/feed/entry">
<simplelayout axis="y"/>
<text datapath="published/text()" width="900"/>
<text datapath="title/text()" fontstyle="bold" fontsize="15" width="900"/>
<text datapath="content/text()" multiline="true" width="900" fontsize="12"/>
<text> <br></br> </text>
<text> <br></br> </text>
</view>
</view>
<scrollbar axis="y"/>
</window>
</view>
</canvas>
</code>







Pour lire un flux en ligne, il suffit de modifier le " dataset " : La grammaire XML de OpenLaszlo est assez intutive et elle permet d'avancer assez rapidement même en tatonnant. Le résultat obtenu est biensûr très sommaire (il faudrait au moins ajouter la sauvegardes des flux et la mise automatique et la comptibilité RSS dont la grammaire est différente de RSS) mais c'est une bonne base de départ. Tous les scripts peuvent être testés en ligne ici.

Mise à jour : c'est vraiement galère d'afficher du code dans blogspot. Le code de Laslo a été converti là : http://www.stanford.edu/~bsuter/js/convert.html .

Prise en main de QuartusII

Si (comme moi) vous découvrez Quartus, voici quelques éléments pour prendre en main QuartusII quelques minutes :

Création d'un projet :
Un projet sous QuartusII est un ensemble de fichiers contenant la configuration du design, le design lui même et la hiérachie des différents composants qui le composent. "New Project WIzard" accessible dans le menu "File" permet la création d'un nouveau projet ou la reprise d'un projet existant.

Création d'un bloc (.bdf) :

Quartus permet la conception de système à partir de fichiers verilog (.v) et VHDL (.vhdl) mais il permet aussi (comme sous MAX+Plus II) de concevoir un système par assemblge de schémas blocs. Chaque bloc est associé à un fichier .bdf (Block Design File). Pour créer un nouveau bloc il suffit de cliquer sur "New" dans "File", de sélectionner "Block Diagram/Schematic File" et de cliquer sur "OK". Un onglet d'édition de blocs est alors ouvert dans le cadre principal.
Pour l'enregister ("File"/"Save As") il faut vérifier que la case "Add File to Current Project" soit bien cochée.

La créartion d'un bloc est assez intuitive. L'outils "Block Tool" de la barre d'outils située à gauche, permet de créer un nouveau bloc par "glisser -déposer". Un clic droit sur le bloc et un clic sur "Block Properties" permet d'accéder aux propriétes du bloc (nom, entrée/sorties,etc...).

Insertion de "Primitive Symbols" et de "Megafunctions" :
QuartusII inlcut une bibliothèque de bloc de bases (bascules, compteurs, etc,..). Cette bibliothèque est accessible en double cliquant avec le pointeur de sélection dans un espace vide de la fenêtre d'édition de bloc.

L'insertion de "Megafunctions" (blocs de bases un peu plus évolués) se fait à l'aide du "Mega Wizard Plug In Manager". Il est également accessible en double-cliquant dans un espace vide de la fenêtre. En bas de la fenêtre "Symbol", le bouton "Mega Wizard Plug-in Manager" ouvre l'assistant. Il suffit ensuite de se laisser guider par l'assistant.


Une fois les différents blocs en place, il faut encore ajouter les entrées et les sorties (à partir du dossier I/O dans la fenêtre symbole) et connecter les différents blocs.


Compilation vers la cible :
Le jusqu'à maintenant nous sommes intéressé au design sans tenir compte de la cible. Il faut spécifier au compilateur le FPGA ciblé, lui préciser les contraintes de compilation (vitesse, surface,...) et affecter chaque ports du schéma bloc aux pins du circuit.

Une partie des options est accessible depuis le menu "Assignement" puis "Settings" :
- spécifier la cible : "Device";
- réglage de la compilation : "Compilation Process Settings";
- contraintes de compilation : "Analysis & Synthesis Settings"


Définitions des pins :
Une fois le desing terminé il faut relier les pins du .bdf (indentifés par le nom qu'on leur a donné) aux pins du circuit. Par un clic droit sur le pin du .bdf, on accède au menu "Locate" on choisit "Locate in Assignement Editor". Dans la fenêtre "Assignement Editor" on précise "Location" dans la colone "Assignment Name" et on définit le pin de sortie dans la colone "Value".
Les pin de sortie sont identifié par une (deux) lettre(s) et un nombre. La fenêtre "Pin Planner" donne permet de connaître le positionnement de chaque pin sur le packge.
Dans le cas ou l'on utilise une carte de developpement, les correspondances pin/périphériques sont définies dans la datasheet de la carte.

Remarques : les différents éditeurs présentés ci-dessus sont accessible par des raccourcis au-dessus du cadre principal.


Voilà, vous en savez autant que moi ;). J'ajoute qu'un tutoriel complet est accessible dans le menu "Help" rubrique "Tutorial". Comme tout IDE, la prise en main de quartus vient avec la pratique (lieu commun...). Mais n'hésitez pas à jetter un coup d'oeil dans l'aide, qui est plutôt bien documentée, si vous bloquez.

Bon courage !!