Analyse du circuit
Le circuit logique dont l’étude est proposée ici est composé de :
-
5 portes AND dont une des entrées est inversée
-
5 portes XOR
Remarque : il est à noter ici que, contrairement à la notation habituelle, x0 est le bit de poids fort et x4 le bit de poids faible.
Simulation du circuit en Verilog
Verilog est un langage de description matérielle (HDL - Hardware Description Language) utilisé pour modéliser et concevoir des systèmes électroniques numériques. Il a été créé par Phil Moorby chez Gateway Design Automation en 1984.
Description du circuit
Le fichier circuit.v est édité dans Visual Studio Code avec l’extension Verilog de Masahiro Hiramori.
module circuit_test;
// Déclaration des registres et fils
reg [0:4] x; // Registre d'entrée sur 5 bits (x0 est MSB)
wire [0:4] z, w, y; // Fils intermédiaires et de sortie
reg [0:4] y_exp; // Registre pour stocker la sortie attendue lors des tests
// Portes AND : détectent les transitions 1->0 entre bits adjacents cycliques
// x[4] et x[0] sont considérés comme adjacents (structure circulaire)
and(w[0], x[4], !x[0]); // w[0] = 1 si x[4]=1 et x[0]=0
and(w[1], x[0], !x[1]); // w[1] = 1 si x[0]=1 et x[1]=0
and(w[2], x[1], !x[2]); // w[2] = 1 si x[1]=1 et x[2]=0
and(w[3], x[2], !x[3]); // w[3] = 1 si x[2]=1 et x[3]=0
and(w[4], x[3], !x[4]); // w[4] = 1 si x[3]=1 et x[4]=0
// Portes XOR : modifient les bits d'entrée selon les transitions détectées
// Le bit de sortie y[i] est modifié si une transition a été détectée à la position précédente
xor(y[0], w[4], x[0]); // y[0] inversé si transition avant x[0]
xor(y[1], w[0], x[1]); // y[1] inversé si transition avant x[1]
xor(y[2], w[1], x[2]); // y[2] inversé si transition avant x[2]
xor(y[3], w[2], x[3]); // y[3] inversé si transition avant x[3]
xor(y[4], w[3], x[4]); // y[4] inversé si transition avant x[4]
initial begin
// Bloc de test du circuit
// Premier test avec valeurs connues en entrée et sortie
x = 5'b10000; // Entrée : 10000
y_exp = 5'b10100; // Sortie attendue : 10100
#10; // Attente de 10 unités de temps
// Affichage des résultats
$display("Test 1 results:");
$display("Input (x0,x1,x2,x3,x4) = %b", x);
$display("Output (y0,y1,y2,y3,y4) = %b", y);
// Vérification du résultat
if (y !== y_exp)
$display("Test 1 failed: y incorrect\n val %b\n exp %b", y, y_exp);
else
$display("Test 1 passed: y = %b", y);
// Second test avec sortie inconnue
x = 5'b10011; // Nouvelle entrée : 10011
#10; // Attente de 10 unités de temps
// Affichage des résultats
$display("Test 2 results:");
$display("Input (x0,x1,x2,x3,x4) = %b", x);
$display("Output (y0,y1,y2,y3,y4) = %b", y);
$display("Test complete");
end
// Moniteur pour suivre l'évolution des signaux dans le temps
initial
$monitor("Time=%0t\nIN x=%b\n w=%b\nOUT y=%b\n", $time, x, w, y);
endmodule
Ce code implémente un circuit de test qui :
- Détecte les transitions 1->0 entre bits adjacents (y compris entre le dernier et le premier bit)
- Utilise ces détections pour modifier les bits suivants via des XOR
- Inclut deux cas de test pour vérifier le comportement du circuit
Le circuit pourrait être utilisé pour l’encodage/décodage de données ou la détection de motifs spécifiques dans une séquence binaire.
Simulation du circuit
Le logiciel Icarus Verilog permet de réaliser la simulation https://steveicarus.github.io/iverilog/index.html
Exemple d’utilisation sur Kali (distribution basée sur Debian) :
$ sudo apt install iverilog
$ iverilog -o circuit circuit.v
$ vvp circuit
Time=0
IN x=10000
w=01000
OUT y=10100
Test 1 results:
Input (x0,x1,x2,x3,x4) = 10000
Output (y0,y1,y2,y3,y4) = 10100
Test 1 passed: y = 10100
Time=10
IN x=10011
w=01000
OUT y=10111
Test 2 results:
Input (x0,x1,x2,x3,x4) = 10011
Output (y0,y1,y2,y3,y4) = 10111
Test complete
Le flag est donc FCSC{10111}.
Simulation du circuit en VHDL
VHDL (VHSIC Hardware Description Language) est un langage de description matérielle créé dans les années 1980 par le département de la Défense américain. Le terme VHSIC signifie “Very High Speed Integrated Circuit”.
Description du circuit
Le fichier circuit.vhd est édité avec Visual Studio Code (+ extension VHDL de Pu Zhao)
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
-- Entité principale
entity circuit_test is
end circuit_test;
-- Architecture du circuit
architecture Behavioral of circuit_test is
-- Déclaration des signaux
signal x : std_logic_vector(0 to 4); -- Entrée
signal w : std_logic_vector(0 to 4); -- Signal intermédiaire (AND)
signal y : std_logic_vector(0 to 4); -- Sortie
signal y_exp : std_logic_vector(0 to 4); -- Sortie attendue
begin
-- Portes AND
w(0) <= x(4) and (not x(0));
w(1) <= x(0) and (not x(1));
w(2) <= x(1) and (not x(2));
w(3) <= x(2) and (not x(3));
w(4) <= x(3) and (not x(4));
-- Portes XOR
y(0) <= w(4) xor x(0);
y(1) <= w(0) xor x(1);
y(2) <= w(1) xor x(2);
y(3) <= w(2) xor x(3);
y(4) <= w(3) xor x(4);
-- Processus de test
test_proc: process
begin
-- Test 1 avec valeurs connues
x <= "10000";
y_exp <= "10100";
wait for 10 ns;
-- Affichage des résultats
report "Test 1 results:";
report "Input (x0,x1,x2,x3,x4) = " & to_string(x);
report "Output (y0,y1,y2,y3,y4) = " & to_string(y);
-- Vérification
if (y /= y_exp) then
report "Test 1 failed: y incorrect" severity ERROR;
report "Got: " & to_string(y);
report "Expected: " & to_string(y_exp);
else
report "Test 1 passed: y = " & to_string(y);
end if;
-- Test 2
x <= "10011";
wait for 10 ns;
report "Test 2 results:";
report "Input (x0,x1,x2,x3,x4) = " & to_string(x);
report "Output (y0,y1,y2,y3,y4) = " & to_string(y);
report "Test complete";
wait;
end process;
-- Processus de monitoring
monitor_proc: process
begin
report "Time=" & time'image(now) & " ns" &
" IN x=" & to_string(x) &
" w=" & to_string(w) &
" OUT y=" & to_string(y);
wait on x, w, y;
end process;
end Behavioral;
Simulation du circuit
Exemple d’utilisation de ghdl sur Kali (distribution basée sur Debian) :
sudo apt install ghdl gtkwave
Analyse du fichier
$ ghdl -a --std=08 circuit.vhd
Remarque : Le paramètre --std=08 est passé afin d’avoir accès aux fonctions définis dans le standard VHDL 2008 (to_string notamment)
Élaboration de l’entité
$ ghdl -e --std=08 circuit_test
Lancement de la simulation
$ ghdl -r --std=08 circuit_test
circuit.vhd:83:9:@0ms:(report note): Time=0 fs ns IN x=XXXXX w=XXXXX OUT y=XXXXX
circuit.vhd:83:9:@0ms:(report note): Time=0 fs ns IN x=10000 w=XXXXX OUT y=XXXXX
circuit.vhd:83:9:@0ms:(report note): Time=0 fs ns IN x=10000 w=01000 OUT y=XXXXX
circuit.vhd:83:9:@0ms:(report note): Time=0 fs ns IN x=10000 w=01000 OUT y=10100
circuit.vhd:55:9:@10ns:(report note): Test 1 results:
circuit.vhd:56:9:@10ns:(report note): Input (x0,x1,x2,x3,x4) = 10000
circuit.vhd:57:9:@10ns:(report note): Output (y0,y1,y2,y3,y4) = 10100
circuit.vhd:65:13:@10ns:(report note): Test 1 passed: y = 10100
circuit.vhd:83:9:@10ns:(report note): Time=10000000 fs ns IN x=10011 w=01000 OUT y=10100
circuit.vhd:83:9:@10ns:(report note): Time=10000000 fs ns IN x=10011 w=01000 OUT y=10111
circuit.vhd:72:9:@20ns:(report note): Test 2 results:
circuit.vhd:73:9:@20ns:(report note): Input (x0,x1,x2,x3,x4) = 10011
circuit.vhd:74:9:@20ns:(report note): Output (y0,y1,y2,y3,y4) = 10111
circuit.vhd:75:9:@20ns:(report note): Test complete
On retrouve à nouveau le flag FCSC{10111}.
Comparaison Verilog / VHDL
La principale différence entre Verilog et VHDL concerne la déclaration et l’adressage des vecteurs de bits :
En VHDL :
-- Format : (borne_gauche TO/DOWNTO borne_droite)
signal compteur : std_logic_vector(7 downto 0); -- 8 bits, MSB=7, LSB=0
signal data : std_logic_vector(0 to 7); -- 8 bits, MSB=0, LSB=7
downto: compte de la plus grande valeur vers la plus petiteto: compte de la plus petite valeur vers la plus grande- Le choix impacte l’ordre des bits (MSB/LSB)
- Plus verbeux mais plus explicite
En Verilog :
// Format : [borne_gauche:borne_droite]
reg [7:0] compteur; // 8 bits, MSB=7, LSB=0
reg [0:7] data; // 8 bits, MSB=0, LSB=7
- Utilise simplement
:entre les bornes - La première borne est toujours le MSB (Most Significant Bit)
- La deuxième borne est toujours le LSB (Least Significant Bit)
- Plus concis mais moins explicite sur la direction
Exemple concret :
-- VHDL
signal a : std_logic_vector(3 downto 0); -- a = "1101" : MSB=1, LSB=1
// Verilog équivalent
reg [3:0] a; // a = 4'b1101 : MSB=1, LSB=1
En résumé, VHDL est plus explicite avec ses mots-clés to/downto tandis que Verilog utilise une notation plus compacte avec :. Cette différence reflète la philosophie générale des deux langages : VHDL tend à être plus verbeux mais plus clair, tandis que Verilog privilégie la concision.
Rôles possibles du circuit étudié
À partir de l’analyse du comportement du circuit, voici les rôles possibles :
-
Codage/Décodage de données :
- Encodage pour transmission série
- Transformation réversible des données
- Protection contre les erreurs de transmission
- Scrambling/descrambling (brouillage/débrouillage)
-
Détection de motifs :
- Détection des transitions 1→0
- Identification de séquences spécifiques
- Validation de format de données
- Détection de violations de protocole
-
Synchronisation :
- Marquage des débuts de trame
- Génération de signaux de synchronisation
- Maintien de la synchronisation bit
- Détection de délimiteurs
-
Applications spécifiques :
-
Protocoles de communication série
- Détection de début/fin de trame
- Vérification de la validité des données
- Insertion de bits de contrôle
-
Systèmes de sécurité
- Brouillage simple de données
- Détection de séquences interdites
- Protection basique contre la copie
-
Traitement de signal
- Détection de fronts
- Filtrage de glitches
- Reconstitution d’horloge
-
Compression de données
- Détection de motifs répétitifs
- Encodage de séquences
- Optimisation de bande passante