Lógica digital na DE1-SoC (5/6): máquinas de estados finitos

Você já construiu circuitos que têm memória: um flip-flop guarda um bit, um registrador guarda vários e um contador guarda a contagem atual. Uma máquina de estados finitos (FSM) organiza essa memória em *situações significativas*. A cada instante, a máquina está em exatamente um elemento de um conjunto pequeno e fixo de estados. Em um semáforo, por exemplo, esses estados podem ser VERDE, AMARELO e VERMELHO. O número de estados é finito, daí o nome, e a máquina sempre está em exatamente um deles.

Uma FSM é definida por três elementos:

- Estados — o conjunto finito de situações em que a máquina pode estar. Um deles é o estado de reset, no qual a máquina começa.
- Transições — as regras para passar de um estado a outro. Em cada borda de clock, a máquina observa o estado atual e as entradas e decide em qual estado ficará em seguida. A transição GREEN -> YELLOW significa: “se estiver em GREEN e a condição for satisfeita, vá para YELLOW na próxima borda”.
- Saídas — os valores que a máquina aplica às saídas, aqui os LEDs, em cada situação.

Toda a máquina avança com o clock: em cada borda, ela possivelmente passa a outro estado com base no estado atual e nas entradas atuais, depois mantém esse estado até a borda seguinte. Entre as bordas, ela apenas espera. É o mesmo comportamento de amostragem e retenção que você viu nos flip-flops, agora usado para percorrer uma sequência de estados.

Moore e Mealy. As FSMs têm dois tipos, que diferem apenas na origem das saídas:

- Em uma máquina de Moore, as saídas dependem apenas do estado atual. Se você conhece o estado, conhece as saídas; as entradas não aparecem na equação de saída. O semáforo é Moore: quando o estado é RED, o LED vermelho está aceso, independentemente das entradas.
- Em uma máquina de Mealy, as saídas dependem do estado atual e das entradas atuais em conjunto. O mesmo estado pode produzir saídas diferentes conforme a entrada naquele instante. O detector de sequência é Mealy: ele afirma “detectado” em certo estado *somente quando o bit de entrada também tem o valor correto*.

As saídas de Moore permanecem estáveis enquanto a máquina fica em um estado. As saídas de Mealy podem mudar assim que uma entrada muda, mesmo sem sair do estado. Isso as torna rápidas, mas também possivelmente breves e sujeitas a glitches, o que será importante na câmera.

A estrutura padrão de uma FSM em Verilog. Quase todas as FSMs deste curso são escritas como dois ou três blocos que trabalham juntos:

1. Um registrador de estado — bloco acionado por clock (always @(posedge clock ...)) que guarda o estado atual e, em cada borda, copia o próximo estado. É o único bloco que possui memória.
2. Um bloco de próximo estado — bloco combinacional (always @(*)) que calcula o estado seguinte com base no estado atual e nas entradas. Ele precisa incluir valores padrão — uma atribuição inicial next_state = ... e um caso default: — para que todo caminho atribua um valor; sem isso, seria inferido um latch indesejado.
3. Lógica de saída — instruções assign ou parte de um bloco combinacional que produz as saídas a partir do estado, em Moore, ou do estado e das entradas, em Mealy.

Os dois projetos desta lição seguem exatamente essa estrutura: registrador de estado acionado por clock, bloco always @(*) de próximo estado com valor padrão e lógica de saída.

Antes de construir, observe uma mudança deliberada em relação às lições anteriores.

Nas Lições 2 e 3, os flip-flops e registradores usavam reset síncrono: o reset era testado *dentro* do bloco acionado por clock, como if (!KEY[0]) Q <= 0; dentro de always @(posedge CLOCK_50). Como esse teste só é executado em uma borda de clock, o reset síncrono só produz efeito na próxima borda de subida. Se o clock for lento, o reset espera por ela.

As FSMs desta lição usam um reset assíncrono ativo em nível baixo. Observe a lista de sensibilidade do registrador de estado:

always @(posedge slow_clk or negedge KEY[0]) begin
    if (!KEY[0]) state <= TODO_RESET_STATE;   // assincrono: dispara quando KEY[0] vai a 0
    else         state <= TODO_NEXT_STATE;
end

Adicionar or negedge KEY[0] à lista de sensibilidade faz o bloco reagir imediatamente quando KEY[0] passa para nível baixo, no instante em que você pressiona o botão, e não apenas em uma borda de slow_clk. Assim, pressionar KEY[0] força a máquina ao estado conhecido sem esperar pela próxima borda do clock lento.

Defina claramente a diferença:

- Reset síncrono (Lições 2–3): só produz efeito em uma borda de clock. É limpo e previsível, mas com um clock lento é preciso esperar pela borda.
- Reset assíncrono (Lições 5–6): produz efeito imediato quando o sinal de reset é ativado, independentemente do clock.

Por que mudar aqui? Estas FSMs são acionadas por um slow_clk dividido, cujas bordas ficam separadas por segundos. Com reset síncrono, você poderia pressionar KEY[0] e nada aconteceria por mais de um segundo. Se a máquina estivesse presa, esse seria justamente o momento de precisar de uma saída imediata. O reset assíncrono oferece um “voltar ao início” instantâneo e confiável na placa real. KEY é ativo em nível baixo: negedge KEY[0] é o instante em que o botão é pressionado, e !KEY[0] permanece verdadeiro enquanto ele está pressionado.

Sua primeira FSM é um controlador de semáforo. Ela tem três estados e os percorre em um ciclo fixo, mantendo cada luz durante certo número de pulsos:

GREEN -> YELLOW -> RED -> GREEN -> ...

As conexões são LEDR[0] = verde, LEDR[1] = amarelo, LEDR[2] = vermelho e KEY[0] = reset ativo em nível baixo, que devolve a máquina a GREEN. A máquina recebe um slow_clk dividido: cada borda desse clock é um pulso, de aproximadamente 0,33 s com este divisor.

Esta é uma máquina de Moore. A lógica de saída no fim é:

assign LEDR[0] = TODO_GREEN_LED_EXPRESSION;
assign LEDR[1] = TODO_YELLOW_LED_EXPRESSION;
assign LEDR[2] = TODO_RED_LED_EXPRESSION;

Cada LED é função somente do estado; nenhuma entrada aparece. Conhecer o estado basta para saber qual luz está acesa. Essa é a propriedade que define uma máquina de Moore.

Dois registradores distintos cumprem funções distintas. Leia com atenção o registrador de estado, pois ele contém *duas* memórias que podem ser confundidas:

- state, um reg [1:0], guarda qual luz está acesa agora: GREEN, YELLOW ou RED. Esse é o estado da FSM.
- timer, um reg [2:0], é um contador de permanência separado, que conta quantos pulsos ainda restam no estado atual. Enquanto timer for maior que zero, ele apenas diminui (timer <= timer - 1) e o estado não muda. Somente quando timer chega a 0 a máquina avança para next_state e recarrega timer para a nova luz.

Portanto, o registrador de estado guarda *qual* luz está acesa, e o timer conta *por quanto tempo* ela permanece acesa. São registradores diferentes, com funções diferentes. É o timer que mantém cada luz em vez de deixá-la passar em um único pulso.

Tempos de permanência reais, segundo o código. Ao entrar em cada estado, a máquina recarrega timer. A contagem do valor carregado até 0, inclusive, determina o número de pulsos:

- GREEN carrega timer = 3 e conta 3, 2, 1, 0: 4 pulsos, cerca de 1,33 s.
- YELLOW carrega timer = 1 e conta 1, 0: 2 pulsos, cerca de 0,67 s.
- RED carrega timer = 3: 4 pulsos, cerca de 1,33 s.

Um ciclo completo tem 4 + 2 + 4 = 10 pulsos, aproximadamente 10 x 0,33 s = 3,3 s do início ao fim.

Este é o módulo inicial. O divisor produz slow_clk; o registrador de estado, com reset assíncrono, avança quando o timer expira; o bloco always @(*) calcula a próxima luz; e as três linhas assign formam a lógica de saída de Moore. Preencha os marcadores TODO_* antes de sintetizar.

// Licao 5 - Exercicio 3-A: controlador de semaforo inicial (FSM de Moore)
// Complete a logica de proximo estado e de saida antes de sintetizar.
module leds_mirror(CLOCK_50, KEY, LEDR);
    input        CLOCK_50;
    input  [3:0] KEY;
    output [9:0] LEDR;

    localparam GREEN = 2'd0, YELLOW = 2'd1, RED = 2'd2;
    localparam [24:0] DIV = 25'd16_666_666;
    reg [24:0] div;
    reg        slow_clk;
    always @(posedge CLOCK_50) begin
        if (!KEY[0]) begin div <= 0; slow_clk <= 0; end
        else if (div == DIV) begin div <= 0; slow_clk <= ~slow_clk; end
        else div <= div + 1'b1;
    end

    reg [1:0] state, next_state;
    reg [2:0] timer;
    always @(posedge slow_clk or negedge KEY[0]) begin
        if (!KEY[0]) begin state <= GREEN; timer <= 3'd3; end
        else if (timer == 3'd0) begin
            state <= next_state;
            case (next_state)
                GREEN:   timer <= 3'd3;
                YELLOW:  timer <= 3'd1;
                RED:     timer <= 3'd3;
                default: timer <= 3'd3;
            endcase
        end else timer <= timer - 1'b1;
    end

    always @(*) begin
        case (state)
            GREEN:   next_state = TODO_AFTER_GREEN;
            YELLOW:  next_state = TODO_AFTER_YELLOW;
            RED:     next_state = TODO_AFTER_RED;
            default: next_state = GREEN;
        endcase
    end

    assign LEDR[0]   = TODO_GREEN_LED_EXPRESSION;
    assign LEDR[1]   = TODO_YELLOW_LED_EXPRESSION;
    assign LEDR[2]   = TODO_RED_LED_EXPRESSION;
    assign LEDR[9:3] = 7'b0;
endmodule

Agora construa o semáforo na DE1-SoC real, cronometre cada fase e depois faça alterações.

Envie sua evidência. Aguarde a fase YELLOW e faça uma captura da câmera quando LEDR[1], amarelo, estiver aceso e LEDR[0], verde, e LEDR[2], vermelho, estiverem apagados. Anexe-a abaixo.

Agora faça duas mudanças no projeto.

(Modifique) Altere os tempos de permanência. Edite os valores de recarga de timer para que o ciclo seja GREEN = 6 pulsos, YELLOW = 2 pulsos, RED = 6 pulsos. Como o timer conta do valor carregado até 0, inclusive, N pulsos exigem carregar N - 1: carregue 5 para GREEN, 1 para YELLOW e 5 para RED, tanto no case do registrador de estado quanto na linha de reset se o valor inicial mudar. Sintetize, envie à FPGA e confirme os novos tempos na câmera. Depois calcule a nova duração total do ciclo em pulsos.

(Acrescente) Um estado vermelho piscante. Adicione um quarto estado, FLASH_RED, depois de RED, formando GREEN -> YELLOW -> RED -> FLASH_RED -> GREEN. Em FLASH_RED, o LED vermelho deve alternar entre aceso e apagado por alguns pulsos, por exemplo quatro, e depois a máquina retorna a GREEN. Dicas: aumente a largura de state/next_state para comportar um quarto valor; acrescente FLASH_RED à lista localparam e ao case de próximo estado; atribua-lhe uma permanência no case do timer; e, em FLASH_RED, acione LEDR[2] a partir de um bit que muda em cada pulso, como o bit menos significativo do timer, em vez de um 1 constante. Sintetize, envie e confirme que o LED vermelho pisca antes de voltar ao verde.

Sua segunda FSM observa um fluxo de bits que chegam, um por pulso de clock, em SW[0] e acende um LED quando acaba de encontrar o padrão 1011. Esta é uma máquina de Mealy: ela afirma “detectado” em certo estado *somente quando o bit de entrada também é o correto*, portanto a saída depende do estado e da entrada em conjunto.

As conexões são SW[0] = bit serial de entrada, KEY[0] = reset ativo em nível baixo, LEDR[0] = detectado e LEDR[4:1] = estado atual em codificação one-hot, um LED por estado, para acompanhar a máquina. A borda de subida do slow_clk dividido, isto é, um pulso, ocorre a aproximadamente cada 1,33 s com este divisor.

Os estados. O detector lembra quanto de 1011 já foi reconhecido:

- S0 — nada reconhecido ainda; é o estado de reset.
- S1 — o último bit foi 1; reconheceu 1.
- S2 — reconheceu 10.
- S3 — reconheceu 101.
- S4 — reconheceu o 1011 completo. A partir daqui, a máquina ainda pode iniciar um novo reconhecimento, o que permite detecções sobrepostas: o 1 final de um 1011 pode ser o 1 inicial do seguinte.

Em cada pulso, o bloco de próximo estado observa o estado atual e o bit em SW[0]. A saída detect é ativada dentro de S3 somente quando o bit recebido é 1, pois 101 seguido por 1 completa 1011. Essa é a saída de Mealy, determinada pelo estado e pela entrada.

Por que retemos a saída. Leia com atenção. O sinal de Mealy bruto detect fica alto por apenas um pulso. Em clock rápido, seria invisível; mesmo neste clock lento, um lampejo de cerca de 1,33 s pode passar despercebido na câmera remota. Por isso, detect não é ligado diretamente ao LED. O projeto retém a detecção: um registrador separado, detected_latch, recebe 1 quando detect dispara e permanece em 1 até você pressionar reset. LEDR[0] mostra esse latch. Assim, depois de detectar 1011, o LED acende e fica aceso até KEY[0]. É uma decisão deliberada para observação remota: um evento breve se torna uma indicação estável e fotografável.

Este é o módulo inicial. Observe os dois blocos: um always @(*) combinacional calcula next_state e a saída de Mealy detect; um always @(posedge slow_clk or negedge KEY[0]) acionado por clock guarda o estado e o latch, com reset assíncrono. Preencha os marcadores TODO_* antes de sintetizar.

// Licao 5 - Exercicio 3-B: detector inicial da sequencia 1011 (FSM de Mealy)
// Complete as transicoes, o pulso Mealy detect e a logica de exibicao de estado.
module leds_mirror(CLOCK_50, KEY, SW, LEDR);
    input        CLOCK_50;
    input  [3:0] KEY;
    input  [9:0] SW;
    output [9:0] LEDR;

    localparam [26:0] DIV = TODO_DIVIDER_LIMIT;
    reg [26:0] div;
    reg        slow_clk;
    always @(posedge CLOCK_50) begin
        if (!KEY[0]) begin div <= 0; slow_clk <= 0; end
        else if (div == DIV) begin div <= 0; slow_clk <= ~slow_clk; end
        else div <= div + 1'b1;
    end

    localparam S0=3'd0, S1=3'd1, S2=3'd2, S3=3'd3, S4=3'd4;
    reg [2:0] state, next_state;
    reg       detect;
    always @(*) begin
        next_state = TODO_DEFAULT_NEXT_STATE;
        detect     = 1'b0;
        case (state)
            S0: TODO_TRANSITION_FROM_S0;
            S1: TODO_TRANSITION_FROM_S1;
            S2: TODO_TRANSITION_FROM_S2;
            S3: begin
                TODO_TRANSITION_AND_DETECT_FROM_S3;
            end
            S4: TODO_TRANSITION_FROM_S4;
            default: next_state = TODO_DEFAULT_STATE;
        endcase
    end

    reg detected_latch;
    always @(posedge slow_clk or negedge KEY[0]) begin
        if (!KEY[0]) begin state <= TODO_RESET_STATE; detected_latch <= 1'b0; end
        else begin
            state <= next_state;
            if (detect) detected_latch <= 1'b1;
        end
    end

    assign LEDR[0]   = detected_latch;
    assign LEDR[4:1] = TODO_ONE_HOT_STATE_DISPLAY;
    assign LEDR[9:5] = 5'b0;
endmodule

Agora construa o detector e insira bits manualmente. Para inserir um bit: ajuste SW[0] para o valor desejado, espere um pulso completo do clock lento, cerca de 1,33 s, para que a máquina o amostre na próxima borda de subida, depois mude SW[0] para o bit seguinte e espere outra vez. Observe LEDR[4:1] para acompanhar o estado.

Envie sua evidência. Depois de inserir 1, 0, 1, 1, LEDR[0] fica aceso até o reset, um estado estável que pode ser fotografado. Faça uma captura da câmera mostrando LEDR[0] aceso e anexe-a abaixo.

Agora modifique o detector.

(Modifique) Detecte 101 em vez de 1011. Primeiro desenhe o novo diagrama de estados em papel. Você precisa de estados para “nada reconhecido”, “reconheceu 1” e “reconheceu 10”. A saída de detecção deve disparar quando, no estado “reconheceu 10”, o bit seguinte é 1, completando 101. Considere a sobreposição: depois de detectar 101, o 1 final pode ser o início do próximo 101. Em seguida, edite o Verilog: remova S4, redirecione as transições para ativar detect no passo 10 seguido por 1 e mantenha o latch e a exibição one-hot. Sintetize, envie e confirme que inserir 1, 0, 1 deixa LEDR[0] aceso.

Você construiu duas máquinas de estados finitos na DE1-SoC real: um controlador de semáforo de Moore, cujas saídas dependem apenas do estado e percorrem GREEN -> YELLOW -> RED com um timer de permanência; e um detector de sequência 1011 de Mealy, cuja saída detect depende do estado e da entrada. Você usou a estrutura padrão de uma FSM: registrador de estado acionado por clock, bloco combinacional de próximo estado com valor padrão e lógica de saída. Também usou reset assíncrono ativo em nível baixo para forçar imediatamente um estado conhecido e viu por que uma saída de um pulso é retida para que a câmera remota possa capturá-la.