Projet VHDL

[invitea1f8a97e]

Bonjour à tous, j'ai voulu poster ceci dans les projets électroniques mais apparemment, je n'y suis pas autorisé.

Alors voila, on a un projet totalement libre à réaliser pour un cours d'électronique numérique mais celui-ci doit être fait en VHDL.

Le projet est le suivant:

Ce serait un petit jeu sur bredboard ou carte pré-trouée ou cpld. Le jeu est le suivant, quelques leds vous affichent en binaire un nombre et un affichage digital (7 segments) vous affiche un nombre. Dés que le nombre en binaire correspond au nombre décimal, il faut presser un bouton. Il y aurait un compteur pour le score ainsi que quelques niveaux de difficultés en fonction du score.


Pour se faire, voici les idées que l'assistant m'a véhiculé.

-Un compteur externe "aléatoire" 3 leds ou alors un convertisseur BCD-7seg externe
-Quand celui-ci représente le nombre affiché par notre affichage digital (généré par un GAL), l'utilisateur presse le bouton
-La GAL vérifie l'égalité entre les deux nombres
-Comptage des points et évolution du niveau. Autre compteur pour les points piloté également par la GAL. La valeur du compteur est renvoyée en entrée pour gérer les différents niveaux du jeu (ou alors utiliser une autre solution ?).


Qu'en pensez-vous ?
Qu'elle est la complexité de ce projets ?
Avez-vous des conseils?


D'avance merci.


Sébastien
-----

[jiherve]

Bonsoir,
Déjà il faudra être capable de convertir , in vivo, du binaire en décimal, et c'est pas gagné, sauf bien sur si il n'y a qu'un nibble à convertir!
Pour le reste c'est assez trivial, sauf que programmer des GAL en VHDL c'est tout de même mal adapté.
L'essentiel des problèmes seront localisés sur la détection propre de l'appui.
Pour ce genre de bidouille un µcontroleur sera plus adapté.
JR
Ps : dès qu'apparait l'acronyme VHDL c'est souvent moi qui m'y colle mais là je n'en vois pas l'intérêt(du VHDL).

[invitea1f8a97e]

Le VHDL, tout simplement parce que c'est imposé. Merci de la réponse rapide. On va tout de même devoir le faire comme ça. Je ferai un suivi de l'évolution du projet... il doit être fini pour décembre donc voila.

[invitea1f8a97e]

Voilà comme promis je vous tiens au courant. On a pas encore commencer la réalisation mais on doit finir ça pour le 10 décembre.

Donc voila on va utilisé une GAL22V10D (c'est imposé) et le langage VHDL. (le projet a très légèrement été modifié, on fait varier les deux valeurs en même temps, et quand elles sont égales, l'utilisateur presse le bouton).

On doit donc générer plus ou moins aléatoirement une valeur sur 4 bits pour les 4 leds, et une valeur sur 4 bits également pour l'afficheur 7 segments (bcd-7seg).
On aura un compteur externe (bcd-7seg) qui lui affichera le score. Avec ce score, on augmentera ou non la difficulté.

On pense donc faire un maximum en VHDL dans la GAL pour avoir un minimum de composantes électroniques.
Je suis à la recherche d'une fonction random en VHDL (j'ai trouvé la fonction UNIFORM, je sais pas ce que vous en pensé, mais est-elle applicable à ma situation ?).
Sinon je pensais générer deux nombres aléatoires. Si ceux-ci sont égaux mod 3, générer un nombre aléatoire mod 10 et envoyer cette valeur aux leds et à l'afficheur. S'ils ne sont pas égaux, générer un nombre aléatoire mod 10 pour les leds, et un autre pour l'afficheur 7 seg (tout en vérifiant qu'ils ne soient pas égaux).

Qu'en pensez-vous ?

[A voir en vidéo sur Futura]

[Jack]

Tu es sur de trouver un outil pour programmer le 22V10? Ça devient rare et il y a quelques années, je n'avais trouvé que ispLEVER de lattice. Encore faut-il que les GAL soient du même fabricant.

A+

[invitea1f8a97e]

Exact, c'est l'ispLEVER de chez lattice et la gal est bel et bien du même fabricant.

[invitea1f8a97e]

Salut à tous,

Notre projet à tout doucement évolué et voici le code:

 Cliquez pour afficher

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
use ieee.math_real.all;

entity my_test is

port(
CLK: in std_logic ;
PRESS_BTN: in std_logic;
SCORE_AFF, LED_AFF, SEG_AFF: inout std_logic_vector ( 3 downto 0 );
LEVEL_AFF: inout std_logic_vector (1 downto 0));

-- Attribution des pins

end;

architecture arch_my_test of my_test is

--signal SCORE, LED, SEG: std_logic_vector(3 downto 0) := "0000";
signal VAL1, VAL2: real;


begin
--process de compteur interne
process(CLK)
variable R: real;
variable S1: positive := 358;
variable S2: positive := 1023;

begin
if CLK'event and CLK = '1' then
uniform(S1,S2,R);
if R < 0.5 then
--Recherche valeurs égales
uniform(S1,S2,R);
VAL1 <= 9.0*R;
--Transformation VAL 1 -> binaire
case integer(VAL1) is
when 0 => LED_AFF <= "0000"; --SEG_AFF <= "0000";
when 1 => LED_AFF <= "0001"; --SEG_AFF <= "0001";
when 2 => LED_AFF <= "0010"; --SEG_AFF <= "0010";
when 3 => LED_AFF <= "0011"; --SEG_AFF <= "0011";
when 4 => LED_AFF <= "0100"; --SEG_AFF <= "0100";
when 5 => LED_AFF <= "0101"; --SEG_AFF <= "0101";
when 6 => LED_AFF <= "0110"; --SEG_AFF <= "0110";
when 7 => LED_AFF <= "0111"; --SEG_AFF <= "0111";
when 8 => LED_AFF <= "1000"; --SEG_AFF <= "1000";
when 9 => LED_AFF <= "1001"; --SEG_AFF <= "1001";
when others => null;
end case;
case integer(VAL1) is
when 0 => SEG_AFF <= "0000";
when 1 => SEG_AFF <= "0001";
when 2 => SEG_AFF <= "0010";
when 3 => SEG_AFF <= "0011";
when 4 => SEG_AFF <= "0100";
when 5 => SEG_AFF <= "0101";
when 6 => SEG_AFF <= "0110";
when 7 => SEG_AFF <= "0111";
when 8 => SEG_AFF <= "1000";
when 9 => SEG_AFF <= "1001";
when others => null;
end case;
else
uniform(S1,S2,R);
VAL1 <= 9.0*R;
--Transformation VAL1 -> binaire
case integer(VAL1) is
when 0 => LED_AFF <= "0000";
when 1 => LED_AFF <= "0001";
when 2 => LED_AFF <= "0010";
when 3 => LED_AFF <= "0011";
when 4 => LED_AFF <= "0100";
when 5 => LED_AFF <= "0101";
when 6 => LED_AFF <= "0110";
when 7 => LED_AFF <= "0111";
when 8 => LED_AFF <= "1000";
when 9 => LED_AFF <= "1001";
when others => null;
end case;

uniform(S1,S2,R);
VAL2 <= 9.0*R;
--Transformation VAL2 -> binaire
case integer(VAL2) is
when 0 => SEG_AFF <= "0000";
when 1 => SEG_AFF <= "0001";
when 2 => SEG_AFF <= "0010";
when 3 => SEG_AFF <= "0011";
when 4 => SEG_AFF <= "0100";
when 5 => SEG_AFF <= "0101";
when 6 => SEG_AFF <= "0110";
when 7 => SEG_AFF <= "0111";
when 8 => SEG_AFF <= "1000";
when 9 => SEG_AFF <= "1001";
when others => null;
end case;
end if;
end if;
end process;

SORTIES: process(CLK)
begin
if CLK'event and CLK = '1' then
if (LED_AFF /= SEG_AFF and PRESS_BTN = '1') or (LED_AFF = SEG_AFF and PRESS_BTN = '0') then
SCORE_AFF <= "0000";
LEVEL_AFF <= "00";
elsif (LED_AFF = SEG_AFF and PRESS_BTN = '1') then
SCORE_AFF <= SCORE_AFF + 1;
--augmentation du niveau
if SCORE_AFF /= 0 and (SCORE_AFF = "0010" or SCORE_AFF = "0101" or SCORE_AFF = "1000" or
SCORE_AFF = "1011" or SCORE_AFF = "1110") then
LEVEL_AFF <= LEVEL_AFF + 1;
end if;
end if;
end if;
end process;


end arch_my_test;

On a maintenant un autre petit soucis. On incrémente le "LEVEL_AFF" mais notre petit soucis, c'est de savoir comment faisons-nous pour augmenter la difficulté du jeu? c-à-d accélérer la vitesse d'affichage des valeurs?


Merci beaucoup à vous

[indri]

Question personnel: c'est quoi la fonction uniform(,,) ??

Ps: quelques tabulations rend le code bcp plus lisible

[invitea1f8a97e]

C'est une fonction qui génère un nombre compris entre 0.0 et 1.0 aléatoirement.

PS: C'était tabulé dans mon éditeur de texte, j'ai fait copier coller, et la apparemment, ca ne l'est plus. Désolé :s

[indri]

Ok merci pour l'info.

Sinon elle est à quelle fréquence ta clock? Elle doit être très lente apparament.
Moi je ferais comme ca: avec une clock genre 50MHz je créerais une autre clock en qui dépend du niveau. Elle-même va faire fonctionner chaque process..

Sinon pour l'appui sur un bouton on détecte généralement un flanc du bouton et pas seulement le niveau (sinon on fait qqch à chaque coup de clock)
En faisant qqch du style:

if bp='1' and old_bp='0' then ....
end if;
old_bp<=bp;

[invitea1f8a97e]

C'est mon premier projet en VHDL et j'ai pas tout a fait compris ce que tu voulais dire avec le bouton. Et pour ce qui est de la cloque non plus. Désolé.

Mais le bouton, tu dois le presser quand les deux valeurs sont égales. Sinon tu pousses pas dessus.

[indri]

Ta clock est à quel fréquence?

Si elle est à 50MHz, ton affichage va changer toutes le 20 ns(si j'ai +/- bien compris ton code), faut vachement être rapide pour appuyer sur un bp toutes les 20ns

Donc pour changer moins rapidement, on crée une deuxième clock (de 1 Hz par exemple) à partir de l'autre via un compteur par ex. du style:
if clk'event and clk='1' then
compt:=compt+1;
if compt=25000000 then
compt=0;
clk2=not(clk2);
end if;
end if;


Pour le bp si tu fais :" if bp='1' then" dans un process clocké lorsque tu vas appuyé sur le bouton poussoir, tu n'appui pas qu'une nanoseconde mais plutot 10 ou 100 ms...donc des milliers de flanc montant de ta clock à 50MHz donc des milliers de fois ton process clocké sera appellé alors que toi tu voulais qu'il fasse l'action qu'une fois (et encore je parle pas des antirebonds..) ...bref on repère un flanc montant ou descandant...c'est préférable...

Je sais pas si c'est plus claire

[invitea1f8a97e]

Oui merci... J'ai bien saisis pour le bouton.

Et je définis comment la fréquence de ma clock? J'ai un peu rechercher sur google mais j'ai rien trouvé de bien concret.

[indri]

Ben ca dépend de ta carte...si y a un quartz ou que sais-je...Le fpga génère pas sa propre clock (pas que je sache en tout cas..mais bon il existe peut-être des modèles qui le font...)..