Funções Verilog Explicadas: Sintaxe, Exemplos e Diferença em Relação às Tarefas

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

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

1. O que é uma Função Verilog? (Conceito Básico e Papel)

O que é uma função?

Características Principais das Funções

• Um ou mais inputs podem ser especificados (apenas input é permitido)
• Apenas uma saída (o valor de retorno da função)
• Atrasos de tempo (ex.: #10) não são permitidos
• Funções devem sempre descrever lógica combinacional
• Funções são definidas fora de blocos always e são avaliadas imediatamente (ao contrário de tasks)

Quando Usar Funções Verilog

1. Descrevendo Lógica Combinacional

2. Melhorando a Reutilização de Código

3. Reduzindo Erros de Projeto

Diferença Entre Funções e Tasks

Quando Usar uma Função

• Quando você precisa de um resultado de cálculo imediato
• Para lógica que não inclui atrasos
• Quando um único valor de retorno é suficiente

Quando Usar uma Task

• Quando o processo inclui atrasos (ex.: #10)
• Quando múltiplas saídas são necessárias
• Para propósitos de simulação/depuração (ex.: saída de log)

Resumo

• Uma função Verilog é uma função que recebe inputs e devolve um único valor.
• É mais adequada para descrever lógica combinacional e não pode incluir atrasos.
• Útil para reduzir código redundante e melhorar a legibilidade.
• Funções e tasks são diferentes; a escolha depende do seu caso de uso.

2. Como Escrever uma Função Verilog [Beginner-Friendly Example]

Sintaxe Básica de uma Função

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

Pontos Principais

• Declarada com a palavra‑chave function
• O valor de retorno é atribuído a uma variável com o mesmo nome da função
• Declare os inputs usando input (não é permitido usar output ou inout)
• Realize os cálculos dentro de begin ... end
• Defina a função fora de um bloco always

Exemplo Simples de uma Função 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

Explicação

• add_function recebe duas entradas de 8 bits ( a e b ) e retorna sua soma
• A função é chamada com sum = add_function(x, y); e atribui o resultado a sum
• O bloco initial usa $display para mostrar o resultado

Declarando Entradas e Saídas em uma Função

Declarando Entradas

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

Função com Declarações Condicionais

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

Resumo

• Uma função Verilog é definida com a palavra‑chave function e retorna um único valor
• Apenas argumentos input são permitidos (sem output )
• O valor de retorno é atribuído à variável com o mesmo nome da função
• Declarações if e case podem ser usadas para lógica condicional

3. Como Usar Funções Verilog [With Practical Code Examples]

Como Chamar uma Função

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

Pontos Principais

• Uma função é chamada na forma variável = function(argumentos);
• Pode ser usada dentro de blocos always ou initial
• Funções operam como lógica combinacional

Usando Funções em Lógica Combinacional

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

Explicação

• A função decoder converte uma entrada de 2 bits em uma saída de decodificador de 4 bits
• Usa uma instrução case para decidir a saída com base na entrada
• assign é usado para mapear a saída da função para decoded_output → A função funciona como uma parte da lógica combinacional

Functions vs. Always Blocks [Comparison Table]

Key Guidelines

• Use funções para simplificar operações lógicas simples (lógica combinacional)
• Use blocos always para circuitos que mantêm estado (por exemplo, flip-flops)
• Se precisar de atrasos (como #10), use blocos always em vez de funções

Summary: How to Use Verilog Functions

4. Practical Applications of Verilog Functions (Decoder and ALU Design)

Function Implementation of a Decoder (2-to-4 Decoder)

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

Function Implementation of an ALU (Addition, Subtraction, 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

Summary

5. Considerações Importantes ao Usar Funções Verilog

Chamadas Recursivas Não São Permitidas

❌ Exemplo NG: Função Recursiva

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

✅ Solução: Use Loops Em Vez Disso

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

Atrasos de Tempo (#10) Não Podem Ser Usados Dentro de Funções

❌ Exemplo NG: Atraso Dentro de uma Função

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

✅ Solução: Use Blocos Always Em Vez Disso

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

Escolhendo Entre Funções e Tasks

Quando Usar uma Função

Quando Usar uma Task

Funções Não Podem Ser Definidas Dentro de Blocos Always

❌ Exemplo NG: Definindo uma Função Dentro de 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

✅ Exemplo Correto

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

Resumo

6. [FAQ] Perguntas Frequentes Sobre Funções Verilog

Qual é a diferença entre uma função e uma task?

Q. Qual é a diferença entre uma função Verilog e uma task? Qual devo usar?

Quando usar uma Função

Quando usar uma Task

Posso usar reg dentro de uma função?

Q. Posso declarar variáveis reg dentro de uma função?

✅ Exemplo Correto (Usando integer)

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

Quando devo usar funções?

Q. Em quais situações é adequado usar funções?

• Operações aritméticas (adição, subtração, lógica)
• Decodificadores e codificadores
• Comparações (encontrar valores máximo/mínimo)
• Verificação de erros (ex.: verificação de paridade)

Uma função pode chamar outra função?

Q. Uma função Verilog pode chamar outra função dentro dela?

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

Como devo escolher entre funções e blocos always?

Q. Como devo decidir se uso uma função ou um bloco always?

✅ Função (Lógica Combinacional)

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

✅ Bloco Always (Lógica Sequencial)

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

Resumo