Dominando Funções VHDL: Guia Prático para Design Eficiente
Funções são subprogramas em VHDL que podem ser usados para implementar algoritmos frequentemente utilizados. Uma função recebe zero ou mais valores de entrada e sempre retorna um valor. Além do valor de retorno, o que diferencia uma função de um procedimento é que ela não pode conter declarações Wait. Isso significa que funções sempre consomem tempo de simulação zero.
Se você está familiarizado com funções ou métodos de outras linguagens de programação, funções VHDL devem ser fáceis de compreender. Em VHDL, não podemos omitir o valor de retorno ou retornar void; uma função sempre tem que retornar algo e o valor de retorno tem que ser atribuído a algo.
Este post do blog é parte da série Tutoriais Básicos de VHDL.
Em VHDL, existem dois tipos de funções, puras e impuras. Que uma função seja pura significa que ela não terá permissão para modificar ou ler qualquer sinal externo. Podemos ter certeza de que quando chamamos uma função pura com certos argumentos, ela sempre retornará o mesmo valor. Dizemos que a função não tem efeitos colaterais.
A sintaxe para declarar uma função em VHDL é:
[pure|impure] function <function_name> (<parameter1_name> : <parameter1_type> := <default_value>; <parameter2_name> : <parameter2_type> := <default_value>; ... ) return <return_type> is <constant_or_variable_declaration> begin <code_performed_by_the_function> return <value> end function; A palavra-chave pure/impure é opcional, embora assuma pure se a palavra-chave for omitida. Todos os parâmetros são tratados como constantes dentro da função. Assim, eles não podem ser alterados. Os valores padrão são opcionais, e a função deve sempre terminar em uma declaração return.
Funções têm sua própria região declarativa entre as palavras-chave in e begin. Constantes, sinais ou variáveis declarados aqui são válidos apenas dentro da própria função e não reterão seus valores através de chamadas subsequentes à função.
Exercício
Neste tutorial, vamos focar na função pura; funções impuras serão cobertas em um tutorial posterior desta série.
No tutorial anterior, criamos um módulo controlador de semáforos usando uma máquina de estados finita (FSM). Copiamos e colamos muitas das linhas contendo cálculos de temporizador de um estado para outro, alterando apenas uma constante ligeiramente.
Descubra como você pode simplificar o código da máquina de estados usando uma função:
O código final para o testbench da função:
library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity T21_FunctionTb is end entity; architecture sim of T21_FunctionTb is -- Estamos usando uma frequência de clock baixa para acelerar a simulação constant ClockFrequencyHz : integer := 100; -- 100 Hz constant ClockPeriod : time := 1000 ms / ClockFrequencyHz; signal Clk : std_logic := '1'; signal nRst : std_logic := '0'; signal NorthRed : std_logic; signal NorthYellow : std_logic; signal NorthGreen : std_logic; signal WestRed : std_logic; signal WestYellow : std_logic; signal WestGreen : std_logic; begin -- Device Under Test (DUT) i_TrafficLights : entity work.T21_TrafficLights(rtl) generic map(ClockFrequencyHz => ClockFrequencyHz) port map ( Clk => Clk, nRst => nRst, NorthRed => NorthRed, NorthYellow => NorthYellow, NorthGreen => NorthGreen, WestRed => WestRed, WestYellow => WestYellow, WestGreen => WestGreen); -- Processo para gerar clock Clk <= not Clk after ClockPeriod / 2; -- Sequência do testbench process is begin wait until rising_edge(Clk); wait until rising_edge(Clk); -- Tirar o DUT do reset nRst <= '1'; wait; end process; end architecture;
O código final para o módulo de semáforos:
library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity T21_TrafficLights is generic(ClockFrequencyHz : natural); port( Clk : in std_logic; nRst : in std_logic; -- Reset negativo NorthRed : out std_logic; NorthYellow : out std_logic; NorthGreen : out std_logic; WestRed : out std_logic; WestYellow : out std_logic; WestGreen : out std_logic); end entity; architecture rtl of T21_TrafficLights is -- Declaração de tipo enumerado e declaração de sinal de estado type t_State is (NorthNext, StartNorth, North, StopNorth, WestNext, StartWest, West, StopWest); signal State : t_State; -- Calcular o número de ciclos de clock em minutos/segundos function CounterVal(Minutes : integer := 0; Seconds : integer := 0) return integer is variable TotalSeconds : integer; begin TotalSeconds := Seconds + Minutes * 60; return TotalSeconds * ClockFrequencyHz -1; end function; -- Contador para contar períodos de clock, máximo 1 minuto signal Counter : integer range 0 to CounterVal(Minutes => 1) +1; begin process(Clk) is begin if rising_edge(Clk) then if nRst = '0' then -- Valores de reset NorthRed <= '1'; NorthYellow <= '0'; NorthGreen <= '0'; WestRed <= '1'; WestYellow <= '0'; WestGreen <= '0'; State <= NorthNext; Counter <= 0; else -- Valores padrão NorthRed <= '0'; NorthYellow <= '0'; NorthGreen <= '0'; WestRed <= '0'; WestYellow <= '0'; WestGreen <= '0'; Counter <= Counter + 1; case State is -- Luz vermelha em todas as direções when NorthNext => NorthRed <= '1'; WestRed <= '1'; -- Se 5 segundos se passaram if Counter = CounterVal(Seconds => 5) then Counter <= 0; State <= StartNorth; end if; -- Luz amarela na direção norte/sul when StartNorth => NorthRed <= '1'; NorthYellow <= '1'; WestRed <= '1'; -- Se 5 segundos se passaram if Counter = CounterVal(Seconds => 5) then Counter <= 0; State <= North; end if; -- Luz verde na direção norte/sul when North => NorthGreen <= '1'; WestRed <= '1'; -- Se 1 minuto se passou if Counter = CounterVal(Minutes => 1) then Counter <= 0; State <= StopNorth; end if; -- Luz vermelha e amarela na direção norte/sul when StopNorth => NorthYellow <= '1'; WestRed <= '1'; -- Se 5 segundos se passaram if Counter = CounterVal(Seconds => 5) then Counter <= 0; State <= WestNext; end if; -- Luz vermelha em todas as direções when WestNext => NorthRed <= '1'; WestRed <= '1'; -- Se 5 segundos se passaram if Counter = CounterVal(Seconds => 5) then Counter <= 0; State <= StartWest; end if; -- Luz amarela na direção oeste/leste when StartWest => NorthRed <= '1'; WestRed <= '1'; WestYellow <= '1'; -- Se 5 segundos se passaram if Counter = CounterVal(Seconds => 5) then Counter <= 0; State <= West; end if; -- Luz verde na direção oeste/leste when West => NorthRed <= '1'; WestGreen <= '1'; -- Se 1 minuto se passou if Counter = CounterVal(Minutes => 1) then Counter <= 0; State <= StopWest; end if; -- Luz vermelha e amarela na direção oeste/leste when StopWest => NorthRed <= '1'; WestYellow <= '1'; -- Se 5 segundos se passaram if Counter = CounterVal(Seconds => 5) then Counter <= 0; State <= NorthNext; end if; end case; end if; end if; end process; end architecture;
A forma de onda após inserirmos o comando run 5 min no console do ModelSim:

A forma de onda com cursores adicionados nas transições de e para o estado StartNorth:

Análise
Substituímos os cálculos de temporizador do tutorial anterior if Counter = ClockFrequencyHz * 5 -1 then por uma chamada à nova função CounterVal que criamos: if Counter = CounterVal(Seconds => 5) then.
Podemos ver na primeira captura de tela da forma de onda que a função do módulo permanece inalterada. Usar funções para tarefas repetitivas é uma boa prática de design. Especialmente se você pode substituir cálculos por linhas mais legíveis contendo termos como Minutes e Seconds.
Outra vantagem de usar funções é que podemos mudar a implementação de todos os temporizadores de uma vez, em vez de fazer linha por linha. Por exemplo, se tivéssemos escrito return TotalSeconds * ClockFrequencyHz; na função CounterVal, todos os temporizadores durariam um ciclo de clock a mais. Poderíamos então mudar isso para return TotalSeconds * ClockFrequencyHz -1; na função CounterVal, e todos os temporizadores seriam corrigidos de uma vez.
Se examinarmos a última captura de tela da forma de onda, podemos ver por que precisamos subtrair 1 do valor do temporizador retornado pela função CounterVal. Esta forma de onda examina a duração do estado StartNorth, que deve durar exatamente cinco segundos. Quando o sinal State muda para StartNorth, o valor do Counter é 0, e ele só muda após o próximo ciclo de clock. Então, se tivéssemos contado até 500 ciclos de clock, o estado StartNorth teria durado na verdade 501 ciclos. Com nosso testbench rodando a 100 Hz, 500 ciclos de clock são exatamente cinco segundos.

Conclusão
- Funções podem receber zero ou mais parâmetros, mas sempre retornam um valor
- Funções não podem conter declarações
wait - Funções puras não podem ter efeitos colaterais, enquanto funções impuras podem.
Vá para o próximo tutorial »
VHDL
- Como o Molibdênio Molda a Indústria Moderna: Usos, Benefícios e Dinâmica de Fornecimento
- Criando Listas de Strings em VHDL: Boas Práticas e Exemplo
- Finalizando Graciosamente uma Simulação de Testbench VHDL
- Implementando um Controlador PWM em VHDL: Projeto, Simulação e Demo em FPGA
- Gerando Números Aleatórios em VHDL: De Uniforme a OSVVM
- Aproveitando Procedimentos In-Process para Design de FSM em VHDL Mais Limpo
- Usando Funções Impuras em VHDL: Melhorando Legibilidade e Manutenibilidade de FSM
- Usando realloc() em C: Sintaxe, Boas Práticas e Exemplo
- Dominando a Função free() em C: Guia Prático e Exemplo
- Dominando Técnicas de Retificadora de Ferramentas e Cortadores: Guia Prático