Le blog de f-leb

Dans un signal logique, un front est le passage d’un état logique à un autre état logique.
On distingue :

• le front montant, qui est le passage de l’état bas du signal à l’état haut ;
• le front descendant, qui est le passage de l’état haut du signal à l’état bas.

Fronts montants (flèches rouges), fronts descendants (flèches bleues)

Ces fronts sont très utilisés en logique séquentielle. Si on prend le cas particulier d’un signal d’horloge (clock) qui sert à synchroniser les circuits numériques, les évolutions du système sont déclenchées sur front de l’horloge (front montant en général).
Ce billet décrit ici un circuit logique d’une solution de détection de front (montant ou descendant) sur une carte de développement FPGA, au travers de sa description avec un langage HDL (ici, Verilog, parce que je n'en connais pas d'autres).

L’objectif est résumé dans les chronogrammes ci-dessous :

Le signal d’entrée (in) est un signal logique asynchrone, c’est-à-dire dont les fronts peuvent se présenter à n’importe quel moment, sans lien avec le signal d’horloge (clk). Le signal d’entrée (in) de la simulation montre 6 fronts, entourés en rouge, qu’il s’agit de détecter.
La détection est marquée d’une impulsion sur un cycle d’horloge, repérée en jaune sur le signal de sortie (out). La sortie (out) est synchronisée sur front montant de l’horloge (clk), d’où le petit décalage temporel entre le front et l’impulsion. La solution synchronisée sera d’autant plus pertinente et précise si la fréquence de l’horloge (clk) est grande devant la fréquence du signal d’entrée (in).

La solution envisagée passe par l’utilisation en cascade de deux bascules de type D (repérées a et b sur le schéma ci-dessous) :

« La bascule D (pour Data) est une bascule comportant uniquement une entrée de données : D. La valeur de l'entrée est recopiée sur la sortie à chaque front d'horloge. », d’après Wikipédia.

Regardons les chronogrammes des sorties des deux bascules lorsqu’un front se présente sur le signal d’entrée in (flèche bleue) :

La première bascule (a) ne sert qu’à synchroniser le signal d’entrée (in) avec l’horloge (clk). À sa sortie, le front montant du signal d’entrée (in) est recopié en le décalant au 1^er front montant rencontré de l’horloge (1^re flèche rouge). En cascadant une deuxième bascule (b), on décale à nouveau le signal issu de la bascule (a) au front montant suivant de l’horloge (la 2^e flèche rouge).
Le signal (b) est donc une image « retardée » du signal (a), ce qui permet de comparer à un instant précis un état présent (où le signal d’entrée in est maintenant à l’état haut) avec un état précédent (où le signal d’entrée in était encore à l’état bas).

En effet, entre les deux fronts montants d’horloge (flèches rouges), le signal a est à l’état haut alors que le signal retardé du cycle précédent b est à l’état bas, ce qui indique la présence d’un front montant. Pour la détection d’un front montant, l’équation logique de la sortie out peut alors s’écrire :

• 

Comme il faut aussi détecter les fronts descendants, l’équation logique de la sortie out doit être complétée et devient :

• 

Vous pouvez vérifier en écrivant les tables de vérité :

• 

d’où la présence de la porte XOR (OU exclusif) du circuit logique.

Si en programmation traditionnelle, les lignes du programme mèneront après compilation à des suites d’instructions exécutées séquentiellement par un microprocesseur, il s’agit ici de décrire textuellement des comportements qui synthétiseront le circuit logique voulu à la « compilation » du projet.

Le code Verilog qui amène à synthétiser ce circuit est finalement très court, presque intuitif à l’écriture (c’est le but d’un langage HDL haut niveau), mais rempli de chausse-trapes si on raisonne comme en programmation traditionnelle :

Code verilog :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
module edgeDetector (clk, in, out);

	input clk, in;
	output out;

	reg a, b;  // registres internes

	assign out = a ^ b;  // ^ : symbole du OU exclusif

	always @(posedge clk) begin  // processus sur front montant de l’horloge
		a <= in;
		b <= a;
	end
	
endmodule

• a et b : des « registres » (reg) en Verilog, une entité qui s’approche du concept de variable en programmation traditionnelle, et qui inféreront des bascules D de logique séquentielle à la synthèse (puisque qu’une bascule D « mémorise » un état à des instants précis).
• assign: assignation en continu, toute modification dans les registres a ou b est continuellement répercutée sur la sortie out.
• Bloc always : processus évalué sur front montant (positive edge) de l’horloge.

Parmi les chausse-trapes du langage Verilog, vous aurez à vous confronter au signe <= qui désigne une affectation « non bloquante », à distinguer de l’affectation « bloquante » avec le signe =.
Les guidelines du langage Verilog racontent qu’il faut utiliser des affectations non bloquantes dans les blocs always qui gèrent de la logique séquentielle (et donc des affectations bloquantes pour gérer de la logique combinatoire). Tenez-vous en à ces recommandations si vous débutez, car en expliquer la raison est une tout autre histoire que je ne raconterai pas ici, mais vous pouvez consulter le document à télécharger http://www.sunburst-design.com/paper...2000SJ_NBA.pdf.

Tous les chronogrammes et les schémas de ce billet ont été obtenus par simulation du module Verilog donné plus haut.

À suivre pour un nouveau circuit logique…