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

Todos os projetos até agora foram combinacionais: os LEDs eram uma função pura das posições das chaves *naquele instante*. Ao mudar uma chave, a saída muda assim que o sinal se propaga pelas portas. Um circuito combinacional não tem estado: ele não sabe quais eram as entradas um instante antes e não consegue se lembrar de nada.

Mas a maioria dos sistemas úteis precisa de memória. Um contador deve conhecer seu valor atual para produzir o próximo. Uma CPU precisa manter operandos e resultados entre instruções. Um semáforo deve saber qual cor está acesa para decidir o que vem depois. Nada disso é possível apenas com portas, porque elas sempre refletem somente suas entradas atuais.

Lógica sequencial é a lógica que se lembra. Sua saída depende não só das entradas atuais, mas também de um estado armazenado: o que aconteceu antes. O bloco básico que armazena um bit de estado é o flip-flop, e o marcador de tempo que informa a todos os flip-flops *quando* atualizar é o clock.

A DE1-SoC fornece um clock livre de 50 MHz chamado CLOCK_50: uma onda quadrada que sobe e desce 50.000.000 de vezes por segundo. A partir desta lição, seus projetos sequenciais devem listá-lo como entrada. O modelo padrão leds_mirror.v lista apenas chaves, botões e LEDs e não inclui clock; portanto, você mesmo adicionará input CLOCK_50; ao módulo. Esquecer essa entrada é o erro mais comum em projetos sequenciais.

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

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

Entre as bordas, nada que aconteça na entrada importa: Q fica congelado. Isso é amostragem e retenção: o flip-flop amostra D no instante em que o clock passa de 0 para 1 e mantém essa amostra estável. É assim que um circuito ganha memória: Q pode continuar em 1 muito depois de D voltar a 0, pois se lembra da amostra.

Como escrever isso em Verilog — duas ideias novas.

Primeiro, o bloco acionado por clock. Descrevemos um comportamento acionado por borda com always @(posedge CLOCK_50): as instruções internas são executadas uma vez a cada borda de subida, e não continuamente. Um sinal atribuído dentro desse bloco deve ser declarado como reg, pois mantém um valor entre as bordas.

Segundo, a atribuição não bloqueante <=. Dentro de um bloco acionado por clock, use sempre <=, não =. O operador <= significa “amostre agora todos os lados direitos e depois atualize os lados esquerdos juntos na borda”, exatamente como se comportam flip-flops reais: todos amostram ao mesmo tempo. Usar = — uma atribuição bloqueante — dentro de um bloco acionado por clock é um erro clássico em Verilog: as atribuições passam a valer em sequência dentro da mesma borda, e um flip-flop pode enxergar o valor *novo* de outro em vez do valor anterior, produzindo um hardware diferente do pretendido. Regra prática: <= em blocos acionados por clock; = apenas em lógica combinacional com assign ou always @(*).

Reset síncrono. Também queremos uma forma de forçar Q a voltar a um valor conhecido. Um reset síncrono é verificado *dentro* do bloco acionado por clock, portanto só entra em vigor em uma borda do clock:

always @(posedge CLOCK_50) begin
    if (!KEY[0]) Q <= TODO_RESET_VALUE;   // reset sincrono, avaliado na borda
    else         Q <= TODO_CAPTURED_VALUE;
end

Como KEY é ativa em nível baixo, o botão apresenta 0 quando pressionado; portanto, !KEY[0] é verdadeiro exatamente enquanto o botão de reset está pressionado.

Construa um único flip-flop D na placa real. As conexões são SW[0] = D, KEY[0] = reset (ativo em nível baixo), LEDR[0] = Q e LEDR[1] = ~Q.

Leia isto antes de executar — é importante. A 50 MHz, Q acompanha D 50.000.000 de vezes por segundo, muito mais rápido do que seus olhos ou a câmera conseguem perceber. Portanto, embora este circuito realmente *armazene* D, você não consegue *observar* o armazenamento: ao mudar SW[0], parece que LEDR[0] acompanha a chave imediatamente. Por isso, este exercício demonstra principalmente o reset, e não o armazenamento. O comportamento que você observará é:

- Com SW[0] para cima (D=1), LEDR[0] fica aceso, enquanto LEDR[1], que mostra ~Q, fica apagado.
- Mantenha KEY[0] pressionado — o botão apresenta 0, portanto o reset está ativo. LEDR[0] apaga mesmo que SW[0] continue para cima. O reset tem prioridade sobre os dados.
- Solte KEY[0]: LEDR[0] volta a acompanhar SW[0].

Você *verá* a memória no próximo exercício, 2-B. Por enquanto, concentre-se no reset que substitui a entrada de dados.

// Licao 3 - Exercicio 2-A: modelo inicial de flip-flop D
// SW[0]=D, KEY[0]=reset (ativo em nivel baixo), LEDR[0]=Q, LEDR[1]=~Q.
module leds_mirror(CLOCK_50, SW, KEY, LEDR);
    input        CLOCK_50;
    input  [9:0] SW;
    input  [3:0] KEY;
    output [9:0] LEDR;

    reg Q;
    always @(posedge CLOCK_50) begin
        if (!KEY[0]) Q <= TODO_RESET_VALUE;
        else         Q <= TODO_D_INPUT;
    end

    assign LEDR[0]   = TODO_Q_OUTPUT;
    assign LEDR[1]   = TODO_NOT_Q_OUTPUT;
    assign LEDR[9:2] = 8'b0;
endmodule

Um registrador é simplesmente um conjunto de N flip-flops D lado a lado, todos compartilhando o mesmo clock e o mesmo reset. Um registrador de 8 bits armazena 8 bits. Uma carga paralela copia todos os 8 bits de entrada para o registrador ao mesmo tempo em uma borda do clock: cada flip-flop captura seu próprio bit de dados simultaneamente.

O recurso que torna a memória visível aqui é o controle de carga. Em vez de capturar os dados a *cada* borda, como fazia o flip-flop isolado, este registrador só captura quando você manda. Assim, você pode mudar as chaves à vontade e o valor armazenado permanece igual até que seja feita uma carga. As conexões são SW[7:0] = dados, KEY[0] = reset (ativo em nível baixo) e KEY[1] = carga (ativa em nível baixo).

Como KEY é ativa em nível baixo, você deve pressionar e soltar KEY[1] para carregar: ao pressionar, KEY[1] apresenta 0, e o código verifica !KEY[1] para detectar essa condição. Observe que KEY[1] é *amostrada pelo clock*; ela não é um sinal de clock com eliminação de rebotes em hardware. O projeto simplesmente verifica o nível do botão a cada borda de subida, o que é suficiente para este exercício.

// Licao 3 - Exercicio 2-B: modelo inicial de registrador de carga paralela de 8 bits
// SW[7:0]=dados, KEY[0]=reset (ativo em nivel baixo), KEY[1]=carga (ativa em nivel baixo).
module leds_mirror(CLOCK_50, SW, KEY, LEDR);
    input        CLOCK_50;
    input  [9:0] SW;
    input  [3:0] KEY;
    output [9:0] LEDR;

    reg [7:0] Q;
    always @(posedge CLOCK_50) begin
        if (!KEY[0])      Q <= TODO_RESET_VECTOR;
        else if (!KEY[1]) Q <= TODO_LOAD_VALUE;
    end

    assign LEDR[7:0] = TODO_REGISTER_OUTPUT;
    assign LEDR[9:8] = 2'b00;
endmodule

Envie sua evidência. Faça uma captura da câmera que prove que o registrador está *mantendo* o valor: LEDR[7:0] mostra 10101010, o valor carregado anteriormente, enquanto as chaves na tela SW[7:0] estão em um padrão diferente, como 01010101, e você não pressionou KEY[1]. Mostre na mesma captura os LEDs mantidos e as posições diferentes das chaves e anexe-a abaixo.

Você construiu os dois fundamentos de toda memória em sistemas digitais: o flip-flop D, que armazena um bit por amostragem e retenção na borda do clock, e o registrador, formado por vários flip-flops carregados em paralelo que mantêm o valor até receberem outra instrução. Você usou always @(posedge CLOCK_50) com a atribuição não bloqueante <= e viu uma entrada KEY ativa em nível baixo funcionar como controle.

Uma observação para as próximas lições — dois estilos de reset. Os dois projetos desta lição usaram um reset síncrono: ele foi verificado *dentro* do bloco acionado por clock, portanto só entrou em vigor em uma borda de subida. Isso é simples e previsível, e continuará sendo usado nos elementos de armazenamento desta lição e da próxima. As lições de máquinas de estados finitos, 5 e 6, porém, passarão a usar um reset assíncrono ativo em nível baixo, escrito como always @(posedge CLOCK_50 or negedge KEY[0]), que força o circuito a um estado seguro imediatamente, sem esperar a borda do clock. Isso é útil para recuperar uma máquina de estados travada na placa. A diferença detalhada e a razão para as FSMs preferirem o estilo assíncrono serão explicadas lá. Por enquanto, basta saber que os dois estilos existem e que esta lição usou deliberadamente o síncrono.