Funzioni Verilog spiegate: sintassi, esempi e differenza rispetto ai task

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

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

1. Che cos’è una funzione Verilog? (Concetto di base e ruolo)

Che cos’è una funzione?

Quando utilizzare le funzioni Verilog

1. Descrivere logica combinatoriaPoiché le funzioni restituiscono risultati immediatamente in base agli ingressi, sono spesso usate nella logica combinatoria.

2. Migliorare il riutilizzo del codice

3. Ridurre gli errori di progettazione

Differenza tra funzioni e task

Quando utilizzare una funzione

• Quando è necessario un risultato di calcolo immediato
• Per logica che non include ritardi
• Quando è sufficiente un singolo valore di ritorno

Quando utilizzare un task

• Quando il processo include ritardi (es. #10)
• Quando sono richiesti più output
• Per scopi di simulazione/debug (es. output di log)

Riepilogo

• Una funzione Verilog è una funzione che prende ingressi e restituisce un singolo valore.
• È più adatta per descrivere logica combinatoria e non può includere ritardi.
• Utile per ridurre il codice ridondante e migliorare la leggibilità.
• Funzioni e task differiscono; scegliere quello giusto dipende dal caso d’uso.

2. Come scrivere una funzione Verilog [Beginner-Friendly Example]

Sintassi di base di una funzione

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

Punti chiave

• Dichiar con la parola chiave function
• Il valore di ritorno è assegnato a una variabile con lo stesso nome della funzione
• Dichiarare gli ingressi usando input (non è possibile usare output o inout )
• Eseguire i calcoli all’interno di begin ... end
• Definire la funzione al di fuori di blocco always

Esempio semplice di una funzione 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

Spiegazione

• add_function prende due input a 8‑bit ( a e b ) e restituisce la loro somma
• La funzione è chiamata con sum = add_function(x, y); e assegna il risultato a sum
• Il blocco initial usa $display per mostrare il risultato

Dichiarazione di Input e Output in una Funzione

Dichiarazione degli Input

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

Funzione con Istruzioni Condizionali

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

Riepilogo

• Una funzione Verilog è definita con la parola chiave function e restituisce un unico valore
• Sono consentiti solo argomenti input (nessun output )
• Il valore di ritorno è assegnato alla variabile con lo stesso nome della funzione
• Le istruzioni if e case possono essere usate per la logica condizionale

3. Come Usare le Funzioni Verilog [With Practical Code Examples]

Come Chiamare una Funzione

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

Punti Chiave

Utilizzare le Funzioni nella Logica Combinatoria

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

Spiegazione

• La funzione decoder converte un input a bit in un output decoder a 4 bit
• Usa un’istruzione case per decidere l’output in base all’input
• assign è usato per mappare l’output della funzione a decoded_output → La funzione opera come una parte della logica combinatoria

Funzioni vs. Blocchi always [Comparison Table]

Linee guida principali

• Usa le funzioni per semplificare operazioni logiche semplici (logica combinatoria)
• Usa i blocchi always per circuiti che mantengono stato (ad es., flip‑flop)
• Se hai bisogno di ritardi (come #10), usa i blocchi always invece delle funzioni

Riepilogo: Come usare le funzioni Verilog

4. Applicazioni pratiche delle funzioni Verilog (Progettazione di Decoder e ALU)

Implementazione della funzione di un Decoder (Decoder 2‑to‑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

Implementazione della funzione di una ALU (Addizione, Sottrazione, 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

Riepilogo

5. Considerazioni importanti quando si usano le funzioni Verilog

Le chiam ricorsive non sono consentite

❌ Esempio NG: Funzione ricorsiva

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

✅ Soluzione: Usa i cicli invece

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

I ritardi temporali (#10) non possono essere usati all’interno delle funzioni

❌ Esempio NG: Ritardo all’interno di una funzione

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

✅ Soluzione: Usa i blocchi always invece

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

Scegliere tra funzioni e task

Quando usare una funzione

Quando usare un task

Le funzioni non possono essere definite all’interno di blocchi always

❌ Esempio NG: Definire una funzione dentro 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

✅ Esempio corretto

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

Riepilogo

6. [FAQ] Domande Frequenti sulle Funzioni Verilog

Qual è la differenza tra una funzione e un task?

D. Qual è la differenza tra una funzione Verilog e un task? Quale dovrei usare?

R. Una funzione è usata quando è necessario “restituire un singolo valore immediatamente”, mentre un task è usato quando servono “multiple uscite o operazioni che coinvolgono ritardi”.

Quando Usare una Funzione

Quando Usare un Task

Posso usare reg all’interno di una funzione?

D. Posso dichiarare variabili reg dentro una funzione?

R. No, non è possibile usare reg dentro una funzione, ma puoi usare integer al suo posto.

✅ Esempio Corretto (Usando integer)

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

Quando dovrei usare le funzioni?

D. In quali situazioni è opportuno usare le funzioni?

R. Le funzioni sono più adatte per “operazioni aritmetiche semplici” e “logica combinatoria”.

• Operazioni aritmetiche (addizione, sottrazione, logica)
• Decodificatori e codificatori
• Confronti (trovare valori massimi/minimi)
• Controllo errori (es. controllo di parità)

Una funzione può chiamare un’altra funzione?

D. Una funzione Verilog può chiamare un’altra funzione al suo interno?

R. Sì, una funzione può chiamare un’altra funzione, ma fai attenzione alle dipendenze.

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

Come scegliere tra funzioni e blocchi always?

D. Come decidere se usare una funzione o un blocco always?

R. Le funzioni sono usate per “logica”, mentre i blocchi always sono usati per “logica sequenziale”.

✅ Funzione (Logica Combinatoria)

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

✅ Blocco Always (Logica Sequenziale)

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

Riepilogo