Como um sinal é diferente de uma variável em VHDL

No tutorial anterior aprendemos como declarar uma variável em um processo. As variáveis ​​são boas para criar algoritmos dentro de um processo, mas não são acessíveis ao mundo exterior. Se um escopo de uma variável está apenas dentro de um único processo, como ele pode interagir com qualquer outra lógica? A solução para isso é um sinal .

Os sinais são declarados entre o architecture <architecture_name> of <entity_name> is linha e o begin instruções no arquivo VHDL. Isso é chamado de parte declarativa da arquitetura.

Esta postagem do blog faz parte da série de tutoriais básicos de VHDL.

A sintaxe para declarar um sinal é:
signal <name> : <type>;

Um sinal pode opcionalmente ser declarado com um valor inicial:
signal <name> : <type> := <initial_value>;

Exercício

Neste tutorial em vídeo aprendemos como declarar um sinal. Também aprenderemos a principal diferença entre uma variável e um sinal:



O código final que criamos neste tutorial:

entity T06_SignalTb is
end entity;

architecture sim of T06_SignalTb is

    signal MySignal : integer := 0;

begin

    process is
        variable MyVariable : integer := 0;
    begin

        report "*** Process begin ***";

        MyVariable := MyVariable + 1;
        MySignal   <= MySignal + 1;

        report "MyVariable=" & integer'image(MyVariable) &
            ", MySignal=" & integer'image(MySignal);

        MyVariable := MyVariable + 1;
        MySignal   <= MySignal + 1;

        report "MyVariable=" & integer'image(MyVariable) &
            ", MySignal=" & integer'image(MySignal);

        wait for 10 ns;

        report "MyVariable=" & integer'image(MyVariable) &
            ", MySignal=" & integer'image(MySignal);

    end process;

end architecture;

A saída para o console do simulador quando pressionamos o botão de execução no ModelSim:

VSIM 2> run
# ** Note: *** Process begin ***
#    Time: 0 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: MyVariable=1, MySignal=0
#    Time: 0 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: MyVariable=2, MySignal=0
#    Time: 0 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: MyVariable=2, MySignal=1
#    Time: 10 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: *** Process begin ***
#    Time: 10 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: MyVariable=3, MySignal=1
#    Time: 10 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: MyVariable=4, MySignal=1
#    Time: 10 ns  Iteration: 0  Instance: /t06_signaltb
# ** Note: MyVariable=4, MySignal=2
#    Time: 20 ns  Iteration: 0  Instance: /t06_signaltb
...

Análise

Criamos um sinal e uma variável com o mesmo valor inicial de 0. Em nosso processo, tratamos eles exatamente da mesma maneira, mas as impressões revelam que eles se comportaram de maneira diferente. Primeiro vimos que a atribuição de uma variável e um sinal tem uma notação diferente em VHDL. A atribuição de variável usa o := operador enquanto a atribuição de sinal usa o <= operador.

MyVariable se comporta como se esperaria que uma variável se comportasse. Na primeira iteração do loop, ele é incrementado para 1 e depois para 2. A última impressão da primeira iteração mostra que seu valor ainda é 2, como seria de esperar.

MySignal se comporta um pouco diferente. O primeiro incremento de +1 não parece ter nenhum efeito. A impressão revela que seu valor ainda é 0, o valor inicial. O mesmo acontece após o segundo incremento de +1. Agora o valor de MyVariable é 2, mas o valor de MySignal ainda é 0. Após wait for 10 ns; a terceira impressão mostra que o valor de MySignal é agora 1. As impressões subsequentes também seguem este padrão.

O que é essa feitiçaria? Vou lhe dar uma pista, o wait for 10 ns; tem algo a ver com isso. Os sinais são atualizados apenas quando um processo é pausado. Nosso processo pausa apenas um lugar, em wait for 10 ns; . Portanto, o valor do sinal muda apenas cada vez que esta linha é atingida. Os 10 nanossegundos é um valor arbitrário, pode ser qualquer coisa, até 0 nanossegundos. Tente!

Outra observação importante é esse evento, embora o sinal tenha sido incrementado duas vezes antes do wait , seu valor é incrementado apenas uma vez. Isso ocorre porque ao atribuir um sinal em um processo, a última atribuição “ganha”. O <= operador apenas agenda um novo valor para o sinal, ele não muda até o wait . Portanto, no segundo incremento de MySignal , 1 é adicionado ao seu antigo valor. Quando é incrementado novamente, o primeiro incremento é completamente perdido.

Retirada

• Uma variável pode ser usada em um processo enquanto os sinais têm um escopo mais amplo
• A atribuição de variável é efetivada imediatamente enquanto os sinais são atualizados somente quando um processo é pausado
• Se um sinal for atribuído várias vezes sem um wait , a última tarefa “ganha”

Ir para o próximo tutorial »