Fonctions Verilog expliquées : syntaxe, exemples et différence avec les tâches

By 佐川 直弘 | Naohiro Sagawa (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。

1. Qu’est‑ce qu’une fonction Verilog ? (Concept de base et rôle)

Qu’est‑ce qu’une fonction ?

Caractéristiques principales des fonctions

• Un ou plusieurs entrées peuvent être spécifiées (seul input est autorisé)
• Une seule sortie (la valeur de retour de la fonction)
• Les délais temporels (ex. #10) ne sont pas autorisés
• Les fonctions doivent toujours décrire une logique combinatoire
• Les fonctions sont définies en dehors des blocs always et sont évaluées immédiatement (contrairement aux tasks)

Quand utiliser les fonctions Verilog

1. Décrire une logique combinatoiretant donné que les fonctions renvoient les résultats immédiatement en fonction des entrées, elles sont souvent utilisées dans la logique combinatoire.

2. Améliorer la réutilisabilité du code

3. Réduire les erreurs de conception

Différence entre fonctions et tâches

Quand utiliser une fonction

• Lorsque vous avez besoin d’un résultat de calcul immédiat
• Pour une logique qui n’inclut pas de délais
• Lorsque une seule valeur de retour suffit

Quand utiliser une tâche

• Lorsque le processus inclut des délais (ex. #10)
• Lorsque plusieurs sorties sont requ
• À des fins de simulation/débogage (ex. sortie de journal)

Résumé

• Une fonction Verilog est une fonction qui prend des entrées et renvoie une seule valeur.
• Elle est idéale pour décrire une logique combinatoire et ne peut pas inclure de délais.
• Utile pour réduire le code redondant et améliorer la lisibilité.
• Les fonctions et les tâches diffèrent ; choisir la bonne dépend de votre cas d’utilisation.

2. Comment écrire une fonction Verilog [Beginner-Friendly Example]

Syntaxe de base d’une fonction

function [output_bit_width] function_name;
    input [input_bit_width] input1, input2, ...;
    begin
        function_name = expression;
    end
endfunction

Points clés

• Déclarer avec le mot‑clé function
• La valeur de retour est assignée à une variable portant le même nom que la fonction
• Déclarer les entrées avec input (vous ne pouvez pas utiliser output ou inout )
• Effectuer les calculs à l’intérieur de begin ... end
• Définir la fonction en dehors d’un bloc always

Exemple simple d’une fonction Verilog

module example;
    function [7:0] add_function;
        input [7:0] a, b;
        begin
            add_function = a + b;
        end
    endfunction

    reg [7:0] x, y, sum;

    initial begin
        x = 8'b00001100; // 12
        y = 8'b00000101; // 5
        sum = add_function(x, y);
        $display("Sum: %d", sum); // Sum: 17
    end
endmodule

Explication

• add_function prend deux entrées de 8 bits (a et b) et renvoie leur somme
• La fonction est appelée avec sum = add_function(x, y); et assigne le résultat à sum
• Le bloc initial utilise $display pour afficher le résultat

Déclaration des entrées et sorties dans une fonction

Déclaration des entrées

function [7:0] my_function;
    input [7:0] in1, in2;
    begin
        my_function = in1 & in2; // AND operation
    end
endfunction

Fonction avec instructions conditionnelles

function [3:0] max_function;
    input [3:0] a, b;
    begin
        if (a > b)
            max_function = a;
        else
            max_function = b;
    end
endfunction

Résumé

• Une fonction Verilog est définie avec le mot‑clé function et renvoie une seule valeur
• Seuls les arguments input sont autorisés (pas de output)
• La valeur de retour est assignée à la variable portant le même nom que la fonction
• Les instructions if et case peuvent être utilisées pour la logique conditionnelle

3. Comment utiliser les fonctions Verilog [With Practical Code Examples]

Comment appeler une fonction

module function_example;
    function [7:0] xor_function;
        input [7:0] a, b;
        begin
            xor_function = a ^ b;
        end
    endfunction

    reg [7:0] x, y, result;

    initial begin
        x = 8'b11001100;
        y = 8'b10101010;
        result = xor_function(x, y); // calling the function
        $display("XOR Result: %b", result); // XOR Result: 01100110
    end
endmodule

Points clés

• Une fonction est appelée sous la forme variable = function(arguments);
• Elle peut être utilisée à l’intérieur de blocs always ou initial
• Les fonctions fonctionnent comme de la logique combinatoire

Utilisation des fonctions dans la logique combinatoire

module decoder_example;
    function [3:0] decoder;
        input [1:0] sel;
        begin
            case (sel)
                2'b00: decoder = 4'b0001;
                2'b01: decoder = 4'b0010;
                2'b10: decoder = 4'b0100;
                2'b11: decoder = 4'b1000;
                default: decoder = 4'b0000;
            endcase
        end
    endfunction

    reg [1:0] select;
    wire [3:0] decoded_output;

    assign decoded_output = decoder(select); // using the function

    initial begin
        select = 2'b01;
        #10; // add delay to observe simulation changes
        $display("Decoded Output: %b", decoded_output); // Decoded Output: 0010
    end
endmodule

Explication

• La fonction decoder convertit une entrée de 2 bits en une sortie de décodeur de 4 bits
• Utilise une instruction case pour déterminer la sortie en fonction de l’entrée
• assign est utilisé pour mapper la sortie de la fonction à decoded_output → La fonction fonctionne comme une partie de la logique combinatoire

Fonctions vs. Blocs always [Comparison Table]

Directives clés

• Utilisez les fonctions pour simplifier les opérations logiques simples (logique combinatoire)
• Utilisez les blocs always pour les circuits qui conservent un état (par ex., bascules)
• Si vous avez besoin de délais (comme #10), utilisez des blocs always plutôt que des fonctions

Résumé : Comment utiliser les fonctions Verilog

4. Applications pratiques des fonctions Verilog (Conception de décodeur et d’ALU)

Implémentation fonctionnelle d’un décodeur (décodeur 2‑à‑4)

module decoder_example;
    function [3:0] decoder;
        input [1:0] sel;
        begin
            case (sel)
                2'b00: decoder = 4'b0001;
                2'b01: decoder = 4'b0010;
                2'b10: decoder = 4'b0100;
                2'b11: decoder = 4'b1000;
                default: decoder = 4'b0000;
            endcase
        end
    endfunction

    reg [1:0] select;
    wire [3:0] decoded_output;

    assign decoded_output = decoder(select); // using the function

    initial begin
        select = 2'b00; #10;
        $display("Decoded Output: %b", decoded_output);
        select = 2'b01; #10;
        $display("Decoded Output: %b", decoded_output);
        select = 2'b10; #10;
        $display("Decoded Output: %b", decoded_output);
        select = 2'b11; #10;
        $display("Decoded Output: %b", decoded_output);
    end
endmodule

Implémentation fonctionnelle d’une ALU (Addition, Soustraction, AND, OR)

module alu_example;
    function [7:0] alu;
        input [7:0] a, b;
        input [1:0] op; // 2-bit control signal
        begin
            case (op)
                2'b00: alu = a + b; // Addition
                2'b01: alu = a - b; // Subtraction
                2'b10: alu = a & b; // AND
                2'b11: alu = a | b; // OR
                default: alu = 8'b00000000;
            endcase
        end
    endfunction

    reg [7:0] x, y;
    reg [1:0] opcode;
    wire [7:0] result;

    assign result = alu(x, y, opcode); // using the function

    initial begin
        x = 8'b00001100; // 12
        y = 8'b00000101; // 5

        opcode = 2'b00; #10;
        $display("Addition Result: %d", result); // 12 + 5 = 17

        opcode = 2'b01; #10;
        $display("Subtraction Result: %d", result); // 12 - 5 = 7

        opcode = 2'b10; #10;
        $display("AND Result: %b", result); // AND operation

        opcode = 2'b11; #10;
        $display("OR Result: %b", result); // OR operation
    end
endmodule

Résumé

5. Considérations importantes lors de l’utilisation des fonctions Verilog

Les appels récursifs ne sont pas autorisés

❌ Exemple NG : Fonction récursive

function [3:0] factorial;
    input [3:0] n;
    begin
        if (n == 0)
            factorial = 1;
        else
            factorial = n * factorial(n - 1); // ❌ Recursive call not allowed
    end
endfunction

✅ Solution : Utiliser des boucles à la place

task factorial_task;
    input [3:0] n;
    output [15:0] result;
    integer i;
    begin
        result = 1;
        for (i = 1; i <= n; i = i + 1)
            result = result * i;
    end
endtask

Les délais temporels (#10) ne peuvent pas être utilisés dans les fonctions

❌ Exemple NG : Délai à l’intérieur d’une fonction

function [7:0] delay_function;
    input [7:0] in;
    begin
        #10; // ❌ Delay not allowed inside functions
        delay_function = in + 1;
    end
endfunction

✅ Solution : Utiliser des blocs always à la place

task delay_task;
    input [7:0] in;
    output [7:0] out;
    begin
        #10;
        out = in + 1;
    end
endtask

Choisir entre fonctions et tâches

Quand utiliser une fonction

Quand utiliser une tâche

Les fonctions ne peuvent pas être définies à l’intérieur de blocs always

❌ Exemple NG : Définir une fonction à l’intérieur d’un always

always @(a or b) begin
    function [7:0] my_function; // ❌ Not allowed inside always
        input [7:0] x, y;
        begin
            my_function = x + y;
        end
    endfunction
end

✅ Exemple correct

function [7:0] add_function;
    input [7:0] x, y;
    begin
        add_function = x + y;
    end
endfunction

always @(a or b) begin
    result = add_function(a, b); // ✅ call the function
end

Résumé

6. [FAQ] Questions fréquemment posées sur les fonctions Verilog

Quelle est la différence entre une fonction et une tâche ?

Q. Quelle est la différence entre une fonction Verilog et une tâche ? Laquelle devrais-je utiliser ?

A. Une fonction est utilisée lorsque vous avez besoin de « renvoyer une seule valeur immédiatement », tandis qu’une tâche est utilisée lorsque vous avez besoin de « plusieurs sorties ou d’opérations impliquant des délais ».

Quand utiliser une fonction

Quand utiliser une tâche

Q. Puis-je utiliser reg à l’intérieur d’une fonction ?

A. Non, vous ne pouvez pas utiliser reg à l’une fonction, mais vous pouvez utiliser integer à la place.

✅ Exemple correct (utilisant integer)

function [7:0] multiply;
    input [3:0] a, b;
    integer temp;
    begin
        temp = a * b;
        multiply = temp;
    end
endfunction

Quand devrais-je utiliser des fonctions ?

Q. Dans quelles situations-il approprié d’utiliser des fonctions ?

A. Les fonctions conviennent le mieux aux « opérations arithmétiques simples » et à la « logique combinatoire ».

• Opérations arithmétiques (addition, soustraction, logique)
• Décodeurs et encodeurs
• Comparaisons (trouver les valeurs maximale/minimale)
• Vérification d’erreurs (par ex., contrôle de parité)

Q. Une fonction Verilog peut-elle appeler une autre fonction à l’intérieur ?

A. Oui, une fonction peut appeler une autre fonction, mais soyez prudent avec les dépendances.

function [7:0] add;
    input [7:0] a, b;
    begin
        add = a + b;
    end
endfunction

function [7:0] double_add;
    input [7:0] x, y;
    begin
        double_add = add(x, y) * 2; // calling another function
    end
endfunction

Q. Comment devrais-je décider d’utiliser une fonction ou un bloc always ?

A. Les fonctions sont utilisées pour la « logique combinatoire », tandis que les blocs always sont utilisés pour la « logique séquentielle ».

✅ Fonction (Logique combinatoire)

function [7:0] add;
    input [7:0] a, b;
    begin
        add = a + b;
    end
endfunction

✅ Bloc always (Logique séquentielle)

always @(posedge clk) begin
    sum <= a + b; // works as a flip-flop
end

Résumé