Problème VHDL compteur synchrone

[invite814275d1]

Bonjour à tous,

Je viens vers vous pour vous demander conseils.
Voilà je sais réaliser des compteurs synchrones et asynchrones en pure logique avec des bascules JK ou D.
Ici on veut réaliser la même chose mais en FPGA (programmation VHDL).

Si on met plusieurs compteurs asynchrones en cascade on rencontre aucun problème. Sachant que la sortie de la retenue du premier compteur sera le signal d'horloge du compteur suivant.

Par contre ici je veux réaliser des compteurs synchrone en cascades. Gérer les états suivants est une chose bien plus compliquée ...

Je vous explique mon problème :


Sur l'image dans le cercle vert, j'ai besoin de dire en vhdl que le compteur doit compter sur le front descendant de ca retenue. Car sinon celui-ci va compter dès le début de la retenue et la ca ne fonctionnera pu comme il le faut.
Mais comment faire ?
Car en vhdl on compte celon le front montant de l'horloge.
Je vais pas rajouter une condition en plus sur le front descendant de la retenue ca va proser des problèmes au niveau de la compilation.
Comment gérer cela en VHDL ?

Bien cordialement,

Justin
-----

[stefjm]

VHDL ou pas, les retenue sont gérées en général sur niveau et pas sur front.
Quand on compte, on met la retenue à 1 quand on arrive à 9 pour qu'au coup d'horloge suivant on ait 10, synchrone avec l'horloge.

[invite814275d1]

Pfiouuu !!
Mais quel C.. "Désolé"
J'ai mal positionné ma retenue, c'est pour ça !
Ca fait des heures que je cherche une solution pour rien !!
merci

[jiherve]

Bonsoir,
1:en VHDL on ne se pose pas ce genre de question sauf à des fins didactiques.
un compteur en VHDL c'est :
cpt <= cpt+1; avec cpt déclaré comme un unsigned(size-1, downto 0)
ou bien
cpt <= std_logic_vector(unsigned(cpt) +1); si cpt est un std_logic_vector(size-1, downto 0)
faire une description bascule par bascule est improductif et inefficace.

2: le VHDL n'impose rien quant au front d'horloge actif des bascules il existe:
if rising_egde(clock)
et
if falling_edge(clock)

Pour finir il serait souhaitable de faire la différence entre çà et sa car en plus du VHDL il est indispensable de maitriser le français.
JR

[A voir en vidéo sur Futura]

[stefjm]

1:en VHDL on ne se pose pas ce genre de question sauf à des fins didactiques.
un compteur en VHDL c'est :
cpt <= cpt+1; avec cpt déclaré comme un unsigned(size-1, downto 0)
ou bien
cpt <= std_logic_vector(unsigned(cpt) +1); si cpt est un std_logic_vector(size-1, downto 0)
faire une description bascule par bascule est improductif et inefficace.

Sans descendre jusqu'à la bascule, on peut instancier deux compteurs synchrones. (et sans regarder le code des compteurs)

2: le VHDL n'impose rien quant au front d'horloge actif des bascules il existe:
if rising_egde(clock)
et
if falling_edge(clock)

Il avait été question du front descendent de la retenue (et pas de l'horloge)
D'où mon inquiétude et ma réponse.

[jiherve]

Re
Pour être précis tu as répondu le temps que je tape ma réponse, madame m'ayant fait perdre quelque temps, en mode édition on ne sait pas que le fil se modifie, certains forum offre l'info au moment de poster, Futura devrait peut être y penser.
ceci dit si le FPGA le permet on peut faire une horloge avec n'importe quel signal, et sauf cas très particulier c'est très cochon cela signe une conception qui n'est pas immaculée.

JR

[invite814275d1]

Bonjour,

Re
Pour être précis tu as répondu le temps que je tape ma réponse, madame m'ayant fait perdre quelque temps, en mode édition on ne sait pas que le fil se modifie, certains forum offre l'info au moment de poster, Futura devrait peut être y penser.

jiherve -> Si le sujet est certains forum il faut écrire offrent ! C'est bien de savoir parler correctement Français, mais c'est bien de savoir conjuguer les verbes.

Désolé, mais c'est dans ma nature. Quand on me fait des remarques comme les tiennes, cela m'insupporte.
Je fais déjà des documentations à longueur de journée pour le boulot. Donc vous m'excuserez si quelques fautes m'ont échappé.

Pour en revenir à mon problème.
Je tiens à dire merci à stefjm, car son premier message a résolu mon problème qui n'était pas un problème d'interprétation de bascule JK ou D. Mais juste un problème au niveau du placement de la retenue.

Je programme souvent pour le boulot, des DSPic et Arm cortex en C ou Freertos pour les systèmes temps réels. Mais en FPGA, il faut se dire que ce n'est pas de la pure programmation. Il faut penser niveau système et s'imaginer les bascules qui seront utilisées derrière le code VHDL. C'est un raisonnement assez différent. Mais bon, c'est comme tout, c'est en pratiquant qu'on apprend le plus.

Bien cordialement

Justin

[jiherve]

Bonjour,

Bonjour,

Mais en FPGA, il faut se dire que ce n'est pas de la pure programmation. Il faut penser niveau système et s'imaginer les bascules qui seront utilisées derrière le code VHDL.

Justin

C'est très bien d’être conscient de cet état de fait il n'en demeure pas moins qu'il faut utiliser les "souplesses" du langage pour être efficace, ayant commencé à utiliser des composants programmables (PAL) fin 70'S début 80's et ayant ensuite suivi l’évolution technologique et donc celle des outils de développement/programmation j'ai été très soulagé le jour où sont apparus des langages de haut niveau, je n'en compte pas moins les bascules et cellules utilisées.
Au final effectivement c'est en forgeant que l'on devient forgeron.

JR

[invite814275d1]

Bonsoir,

Bon bah finalement, j'ai parlé trop vite ...
Cela ne fonctionne pas ...

Pour commencer voici mon code :
code.GIF
Comme vous pouvez le voir, il y'a du code en commentaire.
Pourquoi ? Tout simplement parce que j'ai essayé deux solutions.
La première en mettant la retenue dès qu'on a 9.
Comme ça au prochain coup d'horloge le compteur n°1 repasse à zero et le compteur n°2 compte en même temps.
Mais finalement le problème persiste comme au début.
Voici le chronogramme :
chrono.GIF
On peut voir que le problème vient de la retenue.
J'ai donc positionné dans un deuxième temps la retenue quand le compteur passe de 9 à 0 c'est à dire sur le zero.
Mais encore une fois ça ne fonctionnera pas. Pourquoi ? On compte à chaque front d'horloge donc les résultats seront comme ci-dessous :
Cpt1 Ret1 Cpt2
0----0-----0
1----0-----0
2----0-----0
3----0-----0
4----0-----0
5----0-----0
6----0-----0
7----0-----0
8----0-----0
9----0-----0
0----0-----1 //problème : la retenue sera prise en compte au prochain coup d'horloge.
1----1-----0
2----1-----0
3----1-----0

Voilà mon problème ...

J'espère que vous pourrez m'aiguiller dans la bonne direction.

Bien cordialement,

Justin

[invite814275d1]

Erf j'ai dépassé les 5 minutes je ne peux plus corriger mon message.
J'ai fait une petite erreur dans le tableau. Il faut inverser Ret1 et Cpt 2 :
Cpt1 Cpt2 Ret1
0----0-----0
1----0-----0
2----0-----0
3----0-----0
4----0-----0
5----0-----0
6----0-----0
7----0-----0
8----0-----0
9----0-----0
0----0-----1 //problème : la retenue sera prise en compte au prochain coup d'horloge.
1----1-----0
2----1-----0
3----1-----0

[jiherve]

Bonsoir,
dans ton code tu fais deux affectations EF<= EP+1 synchrone et EP<= EF asynchrone et cela ne sert strictement à rien, par ailleurs une carry c'est le "et" logique de la carry de l’étage N avec celles des étages précédents, ce qui n'est pas le cas dans ton code.
Voir schéma interne d'un 74163 par exemple et le schéma de cascadage.
JR

[invite814275d1]

jiherve => Qu'entends tu par synchrone et asynchrone ?
Car pour moi synchrone c'est la même horloge pour tous les compteurs.
Les affectations que j'utilise sont pourtant utiles. EF pour Etat Futur et EP pour Etat Pésent représentatif de la machine à état. C'est toujours important de les différencier.
Pourrais-tu me donner plus d'explications svp ? Peut être que j'interprète mal.
Que me proposerais tu ?

Bien cordialement,

Justin

[invitee05a3fcc]

jiherve => Qu'entends tu par synchrone et asynchrone ?

http://stsserd.free.fr/Cours_sts1/Lo...eurs%20STS.pdf
http://flemarchand.perso.centrale-ma...fr/enum/s9.pdf

[invite814275d1]

Salut,

Oh DAUDET78 -> Il y'avait longtemps dit moi Tu m'avais aidé une fois sur un projet lors de mes études ^^

Merci pour les liens sur les compteurs synchrones et asynchrones. Pour moi la différence entre les deux est acquise depuis longtemps.
C'est juste niveau VHDL.
Pourquoi cette affectation là EF<= EP+1 est synchrone ?
Pourquoi cette affectation là EP <= EF est asynchrone ?

Je pars du principe que mon process s'execute à chaque coup d'horloge.
Une fois sortie du process, je remplace mon état présent par mon état futur déterminé dans le process que j'envoie ensuite sur la sortie.

Bien cordialement,

Justin

[stefjm]

jiherve => Qu'entends tu par synchrone et asynchrone ?

La partie décrite dans le process(H) est décrite séquentiellement, réveillé par H, donc synchrone. Tous les signaux affectés dans le process sont mémorisés et seront donc fittés en sortie de bascules. Tu le fais aussi sur ta retenue ce qui la mémorise dans une bascule, d'où les emmerdes que tu as avec des décallages scabreux (en avance, en retard, j'essaie 8, 9, 0, etc...)
Dans un process, c'est la dernière affectation qui est prise en compte.

La partie décrite hors process est purement combinatoire, donc parallèle.
C'est dans cette partie que tu devrais affecter la retenue qui vaut 1 quand ton compteur vaut 9 et que tu as l'autorisation de comptage.
RCO<='1' when (Cpt=9 and En='1') else '0';
Si tu oublies l'autorisation de comptage dans la condition de la retenue, tu fais compter le compteur suivant à chaque coup, ce qui n'est pas le but...

Car pour moi synchrone c'est la même horloge pour tous les compteurs.

Oui.

Les affectations que j'utilise sont pourtant utiles. EF pour Etat Futur et EP pour Etat Pésent représentatif de la machine à état. C'est toujours important de les différencier.
Pourrais-tu me donner plus d'explications svp ? Peut être que j'interprète mal.

C'est bien d'en avoir conscience. Le VHDL le gère pour toi si tu décris bien.
Dans le process, Cpt est un signal interne, Cpt<=Cpt+1 implémente les bascules. (Avec les if qui vont bien pour compter, décompter, mémoriser, etc...
Hors process, tu affectes combinatoirement et parallèlement la sortie de ton compteur et la retenue.
CptOut<=Cpt;
RCO<='1' when (Cpt=9 and En='1') else '0';


En gros, je dis la même chose que jhervee.
Ce serait instructif d'impliquer Daudet sur cet exemple : il connait les compteurs à l'ancienne. On peut décrire les mêmes en VHDL. (Et souvent, les nouveaux programmeurs VHDL décrivent des compteurs qui amusent les anciens...dont je fais partie.)

Cordialement.

[stefjm]

Pourquoi cette affectation là EF<= EP+1 est synchrone ?

Description séquentielle par process, et synchrone H parce que H est dans la liste de sensibilité du process.

Pourquoi cette affectation là EP <= EF est asynchrone ?

parce que hors process.
Donc affectation concourante, parallèle, asynchrone. (+ les termes que je ne connais pas...)

Je pars du principe que mon process s'execute à chaque coup d'horloge.
Une fois sortie du process, je remplace mon état présent par mon état futur déterminé dans le process que j'envoie ensuite sur la sortie.

C'est globalement correct.
Compte dans le process.
Affecte les sortie hors process.
Calcule correctement la retenue. (et ne la mémorise surtout pas sinon, cela décale d'un cran...)

Cordialement.

[invitee05a3fcc]

Ce serait instructif d'impliquer Daudet sur cet exemple : il connait les compteurs à l'ancienne.

Oui, mais je ne connais pas le VHDL ....
Je me suis arrêté à PALASM qui m'était largement suffisant pour programmer des PALs pour en faire des décodeurs, des compteurs farfelus , des machines d'état

PS : PALASM tourne sur MSDOS ...... nostalgie !

[stefjm]

On peut faire pareil avec avec le VHDL et évidement un peu plus...
https://www.google.fr/search?q=vhdl+arm+core
https://www.google.fr/search?q=risc+vhdl+code

En tout cas, ce fil montre bien que la description de hard d'un simple compteur n'est pas si évidente. (En IUT GEII, on fait cela en première année.)

Perso, a chaque fois que j'oublie de faire les petits dessins des composants, je me plante...

Cordialement;

[invite814275d1]

"Waaouu ! "
Les explications sont claires et précises.
Vous avez répondue à toutes mes questions !
Je vous remercie beaucoup.

stefjm -> Je suis un jeune programmeur en VHDL, mais j'aime aussi la vieille méthode des schémas avant le codage et cela m'aide beaucoup !

J'avoue que le rapprochement des schémas au VHDL est parfois différent ! La preuve je viens de comprendre pourquoi mes affectations étaient synchrones ou asynchrones. Je vais donc effectuer les modifications dans mon code dès ce soir et vous donner un retour.

PS : DAUDET78 -> Si tu veux tous mes cours avec les exercices et logiciels de simulation pour le VHDL n'hésite pas à me demander.

Bien cordialement,

Justin

[jiherve]

Bonjour,
La séparation entre process synchrone et asynchrone pour un compteur ou tout autre machine à états est purement didactique et n'apporte rien au niveau synthèse , cela serait même plutôt le contraire avec certains compilateurs.
Pour les outils bascule sur une version web de Quartus il y a une version simplifiée mais toutefois performante de Modelsim (simulation) qui y est comprise, et Modelsim c'est la référence dans le domaine.
JR

[stefjm]

La séparation entre process synchrone et asynchrone pour un compteur ou tout autre machine à états est purement didactique et n'apporte rien au niveau synthèse , cela serait même plutôt le contraire avec certains compilateurs.

ôtes moi d'un doute, svp.
Tu dis "process asynchrone" pour les "affectations parallèles" (définies hors process)

Si on fait tout dans un process synchrone, on se fait avoir avec la mémorisation de la retenue. (la preuve apportée par justin)

Exemple de code :

Entity Compteur is
    port(
         signal StClock : in std_logic;
         signal StEn     : in std_logic;
         signal Stv4     : out std_logic-vector(3 downto 0);
         signal StRCO   : out std_logic
         )
end Compteur;

Architecture Compteur_Arch of Compteur is
   signal stCpt : std_logic_vector(3 downto 0);
begin
   process(StClock)
      if (StClock'event and StClock='1') then
         if StEn='1' then
            if stCpt=9 then
               StCpt=0;
            else
               stCpt=stCpt+1;
            end if;
         end if;
       end if;
   end process;
   StOut<=StCpt;
   RCO<='1'  when (Cpt=9 and En='1') else '0';
end Compteur_Arch;

Comment coderais-tu l'équivalent? (pour que ce soit à la fois beau et efficace pédagogiquement et matériellement.)

Cordialement.

[jiherve]

Bonsoir,
oui l'asynchrone c'est l'affectation situé hors du process .

Entity Compteur is
    port(
         signal StClock : in std_logic;
         signal StReset : in std_logic; 
         signal StEn     : in std_logic;
         signal Stv4     : out std_logic-vector(3 downto 0);
         signal StRCO   : out std_logic
         )
end Compteur;

Architecture Compteur_Arch of Compteur is
   signal stCpt : std_logic_vector(3 downto 0);
begin
   process(StClock,StReset)
      if StReset = '1' then
            stCpt <=(others => '0');
      elsif (StClock'event and StClock='1') then
         if StEn='1' then
            if stCpt=9 then
               StCpt=0;
            else
               stCpt=stCpt+1;
            end if;
         end if;
       end if;
   end process;
   Stv4<= StCpt;
   StRCO<='1'  when (Cpt=9 and En='1') else '0';
end Compteur_Arch;

Avec ton code il n'y a pas grand chose à modifier sauf rajouter un reset car c'est indispensable et faire deux corrections de nom, on ne peut pas se passer de Stv4<= StCpt; because Stv4 est déclaré en "out".
JR

[stefjm]

Avec ton code il n'y a pas grand chose à modifier sauf rajouter un reset car c'est indispensable et faire deux corrections de nom, on ne peut pas se passer de Stv4<= StCpt; because Stv4 est déclaré en "out".
JR

Ok pour le Reset.
J'avais un doute sur l'optimisation en rapport avec ce que tu avais dit ici :

La séparation entre process synchrone et asynchrone pour un compteur ou tout autre machine à états est purement didactique et n'apporte rien au niveau synthèse , cela serait même plutôt le contraire avec certains compilateurs.

En particulier pour le calcul de la retenue, dans le process ou hors process.

Cordialement.