Lógica digital na DE1-SoC com VHDL (3/6): memória — flip-flops e registradores

Todos os projetos anteriores eram combinacionais: os LEDs dependiam apenas das posições das chaves naquele instante. Ao mudar uma chave, a saída mudava assim que o sinal atravessava as portas. Um circuito combinacional não tem estado: não sabe quais eram as entradas há um momento e não consegue guardar nada.

Mas sistemas úteis precisam de memória. Um contador precisa conhecer seu valor atual para gerar o seguinte. Uma CPU precisa manter operandos e resultados entre instruções. Um semáforo precisa saber qual cor está acesa para decidir a próxima. Portas isoladas refletem apenas as entradas presentes.

Lógica sequencial é a lógica que se lembra. Sua saída depende das entradas atuais e também de um estado armazenado. O flip-flop guarda um bit de estado, e o clock informa quando todos os flip-flops devem se atualizar.

A DE1-SoC fornece um clock livre de 50 MHz chamado CLOCK_50, que sobe e desce 50.000.000 de vezes por segundo. A partir desta lição, os projetos sequenciais precisam declará-lo como entrada. O modelo padrão blink.vhd não inclui clock; você deverá adicionar CLOCK_50 : in std_logic à entidade. Esquecê-lo é um dos erros mais comuns em projetos sequenciais.

Um flip-flop D é o elemento de memória mais simples. Ele tem entrada de dados D, entrada de clock e saída Q. Sua regra é:

> Em cada borda de subida do clock, Q captura o valor de D e o mantém até a próxima borda de subida.

Entre bordas, as mudanças de D não alteram Q. Isso é amostragem e retenção: o flip-flop amostra D quando o clock passa de 0 para 1 e mantém a amostra estável. Assim, Q pode continuar valendo 1 mesmo depois de D voltar a 0.

Duas ideias novas em VHDL.

Primeiro, o processo sincronizado. O comportamento sensível à borda é descrito com process(CLOCK_50) e if rising_edge(CLOCK_50) then. As atribuições dentro do processo indicam o que cada flip-flop captura na borda; não são instruções executadas continuamente.

Segundo, a atribuição de sinal <=. Dentro de um processo sincronizado, Q <= SW(0); descreve a atualização do flip-flop na borda. Variáveis VHDL usam := e mudam imediatamente dentro do processo. Regra deste curso: use sinais e <= para valores armazenados, como flip-flops, registradores, contadores e estados de FSM.

Reset síncrono. Um reset síncrono é verificado *dentro* do bloco do clock e só tem efeito em uma borda:

process(CLOCK_50)
begin
    if rising_edge(CLOCK_50) then
        if KEY(0) = '0' then Q <= TODO_RESET_VALUE;
        else                  Q <= TODO_D_INPUT;
        end if;
    end if;
end process;

KEY é ativo em nível baixo: o botão lê 0 quando pressionado. Portanto, KEY(0) = '0' é verdadeiro enquanto o reset está pressionado.

Monte um flip-flop D na placa real. Use SW(0)=D, KEY(0)=reset ativo em nível baixo, LEDR(0)=Q e LEDR(1)=not Q.

Leia antes de executar. A 50 MHz, Q amostra D 50.000.000 de vezes por segundo, muito mais rápido do que o olho ou a câmera. Por isso, ao mover SW(0), LEDR(0) parece acompanhar imediatamente. Este exercício demonstra visualmente o reset, não a retenção:

- Com SW(0) para cima, LEDR(0) acende e LEDR(1) apaga.
- Mantendo KEY(0) pressionado, LEDR(0) apaga mesmo com SW(0) para cima: o reset vence os dados.
- Ao soltar KEY(0), LEDR(0) volta a acompanhar SW(0).

-- Código inicial do estudante: preencha as linhas TODO antes de sintetizar.
-- Lição 3 - Exercício 2-A: flip-flop D.
-- SW(0)=D, KEY(0)=reset ativo em nível baixo, LEDR(0)=Q, LEDR(1)=not Q.
library ieee;
use ieee.std_logic_1164.all;

entity blink is
    port (
        CLOCK_50 : in  std_logic;
        KEY      : in  std_logic_vector(3 downto 0);
        SW       : in  std_logic_vector(9 downto 0);
        LEDR     : out std_logic_vector(9 downto 0)
    );
end entity blink;

architecture rtl of blink is
    signal Q : std_logic := '0';
begin
    process(CLOCK_50)
    begin
        if rising_edge(CLOCK_50) then
            if KEY(0) = '0' then Q <= TODO_RESET_VALUE;
            else                  Q <= TODO_D_INPUT;
            end if;
        end if;
    end process;

    LEDR(0) <= TODO_Q_OUTPUT;
    LEDR(1) <= TODO_NOT_Q_OUTPUT;
    LEDR(9 downto 2) <= (others => '0');
end architecture rtl;

Um registrador reúne N flip-flops D lado a lado, com o mesmo clock e reset. Um registrador de 8 bits armazena 8 bits. A carga paralela copia os oito bits de entrada ao mesmo tempo em uma borda de clock.

O controle de carga torna a memória visível. O registrador só captura quando solicitado; você pode mudar as chaves e o valor armazenado permanece. Use SW(7 downto 0)=dados, KEY(0)=reset e KEY(1)=carga, ambos ativos em nível baixo.

Para carregar, pressione e solte KEY(1). O código amostra o nível do botão em cada borda de clock, o que é suficiente para este exercício.

-- Código inicial do estudante: preencha as linhas TODO antes de sintetizar.
-- Lição 3 - Exercício 2-B: registrador de carga paralela de 8 bits.
-- SW(7 downto 0)=dados, KEY(0)=reset, KEY(1)=carga. KEY é ativo em nível baixo.
library ieee;
use ieee.std_logic_1164.all;

entity blink is
    port (
        CLOCK_50 : in  std_logic;
        KEY      : in  std_logic_vector(3 downto 0);
        SW       : in  std_logic_vector(9 downto 0);
        LEDR     : out std_logic_vector(9 downto 0)
    );
end entity blink;

architecture rtl of blink is
    signal Q : std_logic_vector(7 downto 0) := (others => '0');
begin
    process(CLOCK_50)
    begin
        if rising_edge(CLOCK_50) then
            if KEY(0) = '0' then
                Q <= TODO_RESET_VECTOR;
            elsif KEY(1) = '0' then
                Q <= TODO_LOAD_VALUE;
            end if; -- caso contrário, Q mantém o valor anterior
        end if;
    end process;

    LEDR(7 downto 0) <= TODO_REGISTER_OUTPUT;
    LEDR(9 downto 8) <= (others => '0');
end architecture rtl;

Envie sua evidência. Faça uma captura que comprove a retenção: LEDR(7 downto 0) deve mostrar 10101010 enquanto as chaves mostram um padrão diferente, como 01010101, sem uma nova pressão em KEY(1).

Você construiu os fundamentos da memória digital: o flip-flop D, que guarda um bit, e o registrador, que reúne vários flip-flops carregados em paralelo. Usou um processo com rising_edge(CLOCK_50), atribuições de sinal <= e entradas KEY ativas em nível baixo.

Os projetos desta lição usam reset síncrono, verificado dentro do processo do clock. Nas lições seguintes, você também encontrará reset assíncrono, escrito com process(..., KEY) e uma verificação de KEY(0) antes da borda. Ele força um estado seguro sem esperar pelo clock lento.