Projetando uma Máquina de Estados Finitos em VHDL: Exemplo Prático de Semáforo

Uma máquina de estados finitos (FSM) é um modelo lógico determinista cuja saída depende não apenas da entrada atual, mas também da sequência de entradas e saídas passadas. No design de FPGA e algoritmos VHDL dependentes de tempo, uma FSM é a abstração padrão para capturar comportamento com estado.

FSMs em VHDL são tipicamente implementadas como processos com clock que usam um sinal state para lembrar a última configuração. O sinal de estado atua como um registrador interno, permitindo que o design reaja a eventos que abrangem múltiplos ciclos de clock.

Tutoriais Básicos de VHDL – Parte 3

Semáforos como FSM

Considere uma interseção de quatro vias controlada por semáforos. As luzes ciclam através de um conjunto finito de estados visíveis — por exemplo, Norte/Sul vermelho, Norte/Sul verde, Oeste/Leste vermelho, etc. O tempo de cada estado (5 s para vermelho ou amarelo, 60 s para verde) é impulsionado por ciclos de clock decorridos.

Modelamos esses comportamentos definindo um tipo enumerado que lista todos os estados possíveis:

type t_State is (NorthNext, StartNorth, North, StopNorth, WestNext, StartWest, West, StopWest);

Então declaramos um sinal desse tipo para manter o estado atual:

signal State : t_State;

Com o sinal de estado no lugar, a lógica da FSM vive dentro de um único processo com clock que usa uma declaração case. Cada branch when corresponde a um estado distinto e contém as atribuições de saída para aquele estado. Um contador rastreia o tempo decorrido e impulsiona a transição para o próximo estado quando seu valor atinge um limite predefinido.

Template FSM de Um Processo

process(Clk) is begin if rising_edge(Clk) then if nRst = '0' then State <= <reset_state>; Counter <= 0; else case State is when <state_name> => <set_outputs_for_this_state_here> if <state_change_condition_is_true> then State <= <next_state_name>; end if; ... end case; end if; end if; end process;

Nota: Você pode implementar FSMs usando estilos de um, dois ou três processos. Veja Estilos de FSM Explicados.

Exercício Prático

Abaixo está um exemplo completo e sintetizável que implementa um controlador de semáforo. O design usa um clock de 100 Hz para simplificar a simulação enquanto ainda demonstra temporização realista.

Testbench

library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity T20_FiniteStateMachineTb is end entity; architecture sim of T20_FiniteStateMachineTb is 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 i_TrafficLights : entity work.T20_TrafficLights(rtl) generic map(ClockFrequencyHz => ClockFrequencyHz) port map( Clk => Clk, nRst => nRst, NorthRed => NorthRed, NorthYellow => NorthYellow, NorthGreen => NorthGreen, WestRed => WestRed, WestYellow => WestYellow, WestGreen => WestGreen); Clk <= not Clk after ClockPeriod / 2; process is begin wait until rising_edge(Clk); wait until rising_edge(Clk); nRst <= '1'; wait; end process; end architecture;

Módulo Máquina de Estados

library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity T20_TrafficLights is generic(ClockFrequencyHz : integer); port( Clk : in std_logic; nRst : in std_logic; -- Reset ativo baixo 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 T20_TrafficLights is type t_State is (NorthNext, StartNorth, North, StopNorth, WestNext, StartWest, West, StopWest); signal State : t_State; signal Counter : integer range 0 to ClockFrequencyHz * 60; begin process(Clk) is begin if rising_edge(Clk) then if nRst = '0' then State <= NorthNext; Counter <= 0; NorthRed <= '1'; NorthYellow <= '0'; NorthGreen <= '0'; WestRed <= '1'; WestYellow <= '0'; WestGreen <= '0'; else -- Saídas padrão NorthRed <= '0'; NorthYellow <= '0'; NorthGreen <= '0'; WestRed <= '0'; WestYellow <= '0'; WestGreen <= '0'; Counter <= Counter + 1; case State is when NorthNext => NorthRed <= '1'; WestRed <= '1'; if Counter = ClockFrequencyHz * 5 - 1 then Counter <= 0; State <= StartNorth; end if; when StartNorth => NorthRed <= '1'; NorthYellow <= '1'; WestRed <= '1'; if Counter = ClockFrequencyHz * 5 - 1 then Counter <= 0; State <= North; end if; when North => NorthGreen <= '1'; WestRed <= '1'; if Counter = ClockFrequencyHz * 60 - 1 then Counter <= 0; State <= StopNorth; end if; when StopNorth => NorthYellow <= '1'; WestRed <= '1'; if Counter = ClockFrequencyHz * 5 - 1 then Counter <= 0; State <= WestNext; end if; when WestNext => NorthRed <= '1'; WestRed <= '1'; if Counter = ClockFrequencyHz * 5 - 1 then Counter <= 0; State <= StartWest; end if; when StartWest => NorthRed <= '1'; WestRed <= '1'; WestYellow <= '1'; if Counter = ClockFrequencyHz * 5 - 1 then Counter <= 0; State <= West; end if; when West => NorthRed <= '1'; WestGreen <= '1'; if Counter = ClockFrequencyHz * 60 - 1 then Counter <= 0; State <= StopWest; end if; when StopWest => NorthRed <= '1'; WestYellow <= '1'; if Counter = ClockFrequencyHz * 5 - 1 then Counter <= 0; State <= NorthNext; end if; end case; end if; end if; end process; end architecture;

Rodar a simulação por cinco minutos produz uma forma de onda que mostra a FSM ciclando através de seus oito estados, com fases verdes durando um minuto cada.

Análise

Principais conclusões do código:

• Tipos enumerados restringem o sinal State a um conjunto conhecido de valores válidos, melhorando segurança e legibilidade.
• Todas as saídas são conduzidas com um valor padrão no início do processo; branches de estado subsequentes sobrescrevem apenas os sinais que mudam.
• A variável Counter é o motor de temporização, e seus valores de limite (5 s, 60 s) são derivados da frequência do clock.

A forma de onda resultante confirma que a FSM avança corretamente: o sinal State alterna através dos oito estados definidos, e cada fase verde persiste por um minuto.

Conclusão

• Máquinas de estados finitos são a maneira padrão de implementar lógica sequencial em VHDL.
• Uma declaração case dentro de um processo com clock mapeia limpa cada estado para seu comportamento.
• Tipos enumerados dão segurança em tempo de compilação limitando o conjunto de valores de estado permitidos.

Prossiga para o próximo tutorial para técnicas avançadas de FSM.