Lógica digital na DE1-SoC (4/6): contadores e registradores de deslocamento

Na Lição 3, você construiu circuitos que se lembram de um bit ou de um byte: um flip-flop e um registrador de carga paralela. Cada um atualiza o valor armazenado em uma borda do clock. Nesta lição, você reutilizará essa ideia para construir circuitos que se movem sozinhos a cada borda: um contador que avança por 0, 1, 2, 3, … e um registrador de deslocamento que move seus bits para o lado.

O clock da placa é CLOCK_50, uma onda quadrada de 50 MHz, com 50.000.000 de bordas de subida por segundo. Se um contador avançasse a cada borda de CLOCK_50, ele percorreria todos os dezesseis valores de um contador de 4 bits cerca de três milhões de vezes por segundo. Você veria apenas um borrão estável de LEDs, e a câmera remota, que captura somente alguns quadros por segundo, não teria nenhuma chance de acompanhar.

Por isso, reduzimos a velocidade com um divisor de clock. O divisor também é apenas um contador: ele conta as bordas de CLOCK_50 e, ao atingir uma contagem terminal escolhida, DIV, alterna um sinal mais lento chamado slow_clk e volta a contar. Quanto maior for DIV, mais lento será slow_clk. Em seguida, acionamos o circuito *real* — o contador de 4 bits ou o registrador de deslocamento — com slow_clk em vez de CLOCK_50.

Como em todas as lições, os projetos sequenciais precisam declarar o clock. O modelo padrão leds_mirror.v lista apenas chaves, botões e LEDs e não inclui clock; portanto, cada módulo desta lição adiciona input CLOCK_50; à lista de portas. Os sinais da placa continuam os mesmos: SW[9:0], com uma chave para cima representando 1; KEY[3:0], ativa em nível baixo, de modo que um botão pressionado apresenta 0; LEDR[9:0], ativa em nível alto, acendendo com 1; e HEX0–HEX5, displays de sete segmentos ativos em nível baixo, cujos segmentos acendem com 0.

Um contador é um registrador cujo próximo valor é simplesmente o valor atual mais um. Um contador de 4 bits armazena valores de 0 a 15; depois de 15, ele volta para 0 automaticamente, pois 15 + 1 = 16 = 10000 em binário e somente os quatro bits inferiores são preservados, 0000. Não é necessário código especial para esse retorno: a largura do registrador faz isso.

O projeto abaixo tem duas partes. O divisor conta bordas de CLOCK_50 até DIV e alterna slow_clk. O contador avança uma unidade a cada borda de subida de slow_clk, e KEY[0] o reinicia em 0; como o botão é ativo em nível baixo, mantê-lo pressionado ativa o reset. A contagem aciona LEDR[3:0] em binário e também HEX0 como um único dígito hexadecimal: 0–9 e depois A–F para 10–15.

A temporização, com precisão. Com DIV = 33.333.333, o divisor alterna slow_clk depois de aproximadamente 0,67 segundo, pois 33.333.333 bordas em 50.000.000 por segundo equivalem a cerca de dois terços de segundo. Um passo do contador ocorre apenas em uma borda de subida de slow_clk, e uma onda quadrada tem uma borda de subida por *período completo*: uma transição de baixo para alto e outra de alto para baixo. Assim, o contador avança aproximadamente a cada 1,33 segundo, ou cerca de 0,75 Hz. Espere um novo valor um pouco menos de uma vez por segundo.

Um problema de largura de registrador. O registrador do divisor tem 27 bits de propósito. Um registrador de 26 bits só pode armazenar até 2^26 - 1 = 67.108.863. Um valor como DIV = 100.000.000 simplesmente não cabe em 26 bits, portanto um projeto com essa largura já estaria incorreto antes de executar. Com 27 bits, o registrador armazena até 2^27 - 1 = 134.217.727; assim, tanto DIV = 100.000.000, mais lento, quanto DIV = 8.333.333, mais rápido, cabem e funcionam. Sempre confirme que uma constante cabe no registrador declarado.

Uma ressalva importante. Acionar um registrador diretamente com um slow_clk dividido, como fazemos aqui, é um atalho didático comum porque torna a ideia concreta. Em projetos de produção, normalmente se mantém tudo no único clock rápido CLOCK_50 e se usa uma habilitação de clock: um pulso de um ciclo que diz ao registrador “atualize nesta borda”. Assim, todo o projeto permanece em um clock real, que as ferramentas de síntese conseguem analisar muito melhor. Usamos o clock dividido aqui apenas por ser a forma mais clara de *ver* o contador se mover.

// Licao 4 - Exercicio 2-C: modelo inicial de contador de 4 bits com divisor de clock
// KEY[0]=reset. LEDR[3:0]=contagem, HEX0=contagem como digito hexadecimal.
module leds_mirror(CLOCK_50, KEY, LEDR, HEX0);
    input        CLOCK_50;
    input  [3:0] KEY;
    output [9:0] LEDR;
    output [6:0] HEX0;

    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

    reg [3:0] count;
    always @(posedge slow_clk or negedge KEY[0]) begin
        if (!KEY[0]) count <= TODO_RESET_COUNT;
        else         count <= TODO_NEXT_COUNT;
    end

    assign LEDR[3:0] = TODO_LED_COUNT;
    assign LEDR[9:4] = 6'b0;
    assign HEX0 = TODO_HEX_PATTERN_FOR_COUNT;
endmodule

Construa o contador na placa real, observe-o avançar, reinicie-o e depois teste os outros dois valores de divisor.

Envie sua evidência. Espere um momento em que HEX0 mostre o dígito C, decimal 12, faça uma captura da câmera — LEDR[3:0] deve mostrar 1100 ao mesmo tempo — e anexe-a abaixo.

Um contador simples de 4 bits percorre 0–15 e mostra A–F nos seis valores mais altos. Muitos displays reais, porém, precisam de um único dígito decimal: contar 0, 1, 2, …, 9 e voltar diretamente para 0. Um contador que percorre apenas 0–9 é chamado contador BCD, de decimal codificado em binário.

A mudança é pequena: em vez de deixar o registrador de 4 bits retornar sozinho depois de 15, você detecta quando a contagem chega a 9 e força o próximo valor a 0. Substitua o bloco always do contador por uma lógica com este formato:

reg [3:0] count;
always @(posedge slow_clk or negedge KEY[0]) begin
    if (!KEY[0])           count <= TODO_RESET_COUNT;
    else if (count == TODO_LAST_BCD_DIGIT) count <= TODO_WRAP_VALUE;
    else                   count <= TODO_NEXT_COUNT;
end

Mantenha todo o restante — o divisor, as atribuições de LEDR/HEX0 e a função seg — igual. Agora HEX0 deve percorrer 0 a 9 e nunca mostrar A–F.

Um registrador de deslocamento é uma fileira de flip-flops na qual, a cada borda do clock, cada bit se move para seu vizinho e um bit novo entra por uma das extremidades. Ele está no centro das ligações seriais: protocolos como UART, SPI e I2C enviam dados um bit de cada vez, e o registrador de deslocamento reúne esses bits em um byte ou separa um byte bit por bit.

O projeto abaixo usa um registrador de 8 bits, shreg[7:0]. Em cada borda de subida de slow_clk, enquanto o deslocamento estiver habilitado, ele executa:

shreg <= TODO_SHIFT_LEFT_UPDATE;   // desloque para a esquerda e insira SW[0] no bit correto

Leia o lado direito com atenção: ele pega os sete bits inferiores shreg[6:0], move-os uma posição para cima e insere SW[0] no bit 0. Cada bit se move em direção à extremidade alta, portanto este é um deslocamento para a esquerda. Os controles são SW[0] = bit serial de entrada, KEY[0] = reset ativo em nível baixo e KEY[1] = habilitação de deslocamento ativa em nível baixo: mantenha KEY[1] pressionada para deslocar a cada pulso.

O padrão esperado. Raciocine em vez de confiar na orientação da câmera. Comece em 0000_0000. Ajuste SW[0] = 1 e deixe passar quatro pulsos: o registrador é preenchido a partir do bit 0 e produz 0000_0001, 0000_0011, 0000_0111, 0000_1111. Agora ajuste SW[0] = 0 e deixe passar mais quatro pulsos: zeros entram no bit 0 e empurram os uns para cima e para fora, produzindo 0001_1110, 0011_1100, 0111_1000 e, por fim, 1111_0000. Portanto, depois de quatro 1s seguidos de quatro 0s, shreg[7:0] vale 1111_0000.

Valor dos bits versus o que você vê. Registre tanto o valor binário do registrador quanto o que a câmera mostra. A ordem física dos LEDs na placa pode parecer espelhada em relação à escrita dos bits, com shreg[7] em uma extremidade e shreg[0] na outra. Assim, os LEDs acesos podem parecer invertidos da esquerda para a direita em comparação com 1111_0000. Isso é um efeito de rotulagem e orientação, não um erro lógico; é exatamente por isso que você deve anotar o valor calculado junto à foto.

// Licao 4 - Exercicio 2-D: modelo inicial de registrador de deslocamento de 8 bits
// SW[0]=dado serial de entrada, KEY[0]=reset, KEY[1]=habilitacao de deslocamento.
module leds_mirror(CLOCK_50, SW, KEY, LEDR);
    input        CLOCK_50;
    input  [9:0] SW;
    input  [3:0] KEY;
    output [9:0] LEDR;

    localparam [24:0] DIV = TODO_DIVIDER_LIMIT;
    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 [7:0] shreg;
    always @(posedge slow_clk or negedge KEY[0]) begin
        if (!KEY[0])      shreg <= TODO_RESET_VECTOR;
        else if (!KEY[1]) shreg <= TODO_SHIFT_LEFT_UPDATE;
    end

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

Construa o registrador de deslocamento, observe um único LED aceso percorrer a fileira e depois veja os zeros segui-lo.

Envie sua evidência. Depois de quatro pulsos com SW0=1 e quatro com SW0=0, solte KEY[1] para congelar o padrão, shreg = 1111_0000, faça uma captura da câmera, anote se os LEDs acesos parecem espelhados e anexe-a abaixo.

Desloque para o outro lado. Para fazer o registrador se deslocar para a direita em vez de para a esquerda — cada bit em direção à extremidade baixa, com o novo bit entrando pela extremidade alta, shreg[7] —, você muda uma única linha. Substitua o espaço reservado do deslocamento à esquerda por sua própria expressão de deslocamento à direita.

else if (!KEY[1]) shreg <= TODO_SHIFT_RIGHT_UPDATE;   // desloque para a direita e insira SW[0]

Somente essa linha muda. Agora SW[0] entra em shreg[7], e os sete bits superiores shreg[7:1] descem para shreg[6:0].

Extensão — contador em anel. Um contador em anel realimenta a própria saída do registrador em sua entrada, em vez de receber um novo bit externo, de modo que um padrão fixo circula indefinidamente. Construa um anel que se desloca para a esquerda e realimenta o bit superior no bit inferior. Inicialize o registrador em 0000_0001 para que exatamente um LED aceso percorra a fileira. Use um reset que carregue 8'h01, não 8'h00. Mantenha KEY[1] pressionada e observe um LED circular sem parar.