Lógica digital en la DE1-SoC con VHDL (4/6): contadores y registros opcionales de desplazamiento

En la Lección 3 construiste circuitos que recuerdan un bit o un byte: un biestable y un registro de carga paralela. Cada uno actualiza el valor almacenado en un flanco de reloj. En esta lección reutilizarás esa idea para construir un circuito que se mueve solo en cada flanco: un contador que sube 0, 1, 2, 3, .... Si hay tiempo, una extensión opcional usa la misma idea para un registro de desplazamiento que desliza sus bits lateralmente.

El reloj de la placa es CLOCK_50, una onda cuadrada de 50 MHz: 50.000.000 flancos de subida cada segundo. Si un contador avanzara una vez por cada flanco de CLOCK_50, recorrería los 16 valores de un contador de 4 bits unos tres millones de veces por segundo. No verías pasos legibles, solo un borrón de LED, y la cámara remota, que captura solo unos pocos fotogramas por segundo, no tendría ninguna posibilidad de seguirlo.

Por eso lo ralentizamos con un divisor de reloj. Un divisor de reloj es, en el fondo, otro contador: cuenta flancos de CLOCK_50 y, cuando llega a un valor terminal DIV, invierte una señal más lenta llamada slow_clk y vuelve a empezar. Cuanto mayor sea DIV, más lento será slow_clk. Después usamos slow_clk, en lugar de CLOCK_50, para mover el circuito principal: el contador de 4 bits, o el registro de desplazamiento opcional.

Como en cada lección, los diseños secuenciales deben declarar el reloj. La plantilla inicial de blink.vhd lista solo interruptores, botones y LED, y no tiene reloj, así que cada entidad de esta lección añade CLOCK_50 : in std_logic a la lista de puertos. Las señales de la placa siguen siendo las mismas: SW(9 downto 0) (interruptor arriba = 1), KEY(3 downto 0) (activo en bajo: pulsado lee 0), LEDR(9 downto 0) (activo en alto: encendido con 1) y HEX0-HEX5 (siete segmentos activos en bajo).

Un contador es un registro cuyo siguiente valor es simplemente el valor actual más uno. Un contador de 4 bits guarda valores de 0 a 15; después de 15 vuelve automáticamente a 0, porque 15 + 1 = 16 = 10000 en binario y solo se conservan los cuatro bits bajos (0000). No hace falta escribir código especial para ese retorno: lo produce la anchura del registro.

El diseño de abajo tiene dos partes. El divisor cuenta flancos de CLOCK_50 hasta DIV e invierte slow_clk. El contador avanza una unidad en cada flanco de subida de slow_clk, y KEY(0) lo resetea a 0 (activo en bajo: pulsado significa reset). La cuenta se muestra en LEDR(3 downto 0) en binario y también en HEX0 como un dígito hexadecimal (0-9, luego A-F para 10-15).

El tiempo, dicho con precisión. Con DIV = 33,333,333, el divisor invierte slow_clk después de unos 0,67 segundos: 33.333.333 flancos sobre 50.000.000 por segundo son aproximadamente dos tercios de segundo. Un paso del contador ocurre solo en un flanco de subida de slow_clk, y una onda cuadrada tiene un flanco de subida por *periodo completo* (sube y baja). Por tanto, el contador avanza aproximadamente cada 1,33 segundos, alrededor de 0,75 Hz. Espera ver un valor nuevo un poco más de una vez por segundo.

Un problema típico de anchura de registros. El registro del divisor aquí tiene 27 bits. Es deliberado. Un registro de 26 bits solo puede guardar hasta 2^26 - 1 = 67,108,863. Un valor como DIV = 100,000,000 no cabe en 26 bits, así que un diseño con esa anchura estaría roto antes de ejecutarse. Con 27 bits, el registro llega a 2^27 - 1 = 134,217,727, por lo que tanto DIV = 100,000,000 (más lento) como DIV = 8,333,333 (más rápido) caben y funcionan. Comprueba siempre que una constante cabe en el registro que declaraste.

Una advertencia honesta. Usar slow_clk como reloj de otro registro, como hacemos aquí, es un atajo didáctico frecuente porque hace visible la idea. En diseños de producción normalmente se mantiene todo en el único reloj rápido CLOCK_50 y se usa una habilitación de reloj (*clock enable*): un pulso de un ciclo que dice "actualiza en este flanco". Así todo el diseño queda en un solo reloj real, que las herramientas de síntesis analizan mejor. Aquí usamos el reloj dividido solo porque es la forma más clara de *ver* el contador moverse.

-- Plantilla de estudiante: completa las lineas TODO antes de sintetizar.
-- Lección 4 - Ejercicio 2-C: contador de 4 bits con divisor de reloj.
-- KEY(0)=reset. LEDR(3 downto 0)=count, HEX0=muestra la cuenta como dígito hexadecimal.
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

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

architecture rtl of blink is
    constant DIV : unsigned(26 downto 0) := TODO_VISIBLE_DIVIDER;
    signal div_count : unsigned(26 downto 0) := (others => '0');
    signal slow_clk  : std_logic := '0';
    signal count     : unsigned(3 downto 0) := (others => '0');

    function seg(d : unsigned(3 downto 0)) return std_logic_vector is
    begin
        case d is
            when "0000" => return "1000000"; when "0001" => return "1111001";
            when "0010" => return "0100100"; when "0011" => return "0110000";
            when "0100" => return "0011001"; when "0101" => return "0010010";
            when "0110" => return "0000010"; when "0111" => return "1111000";
            when "1000" => return "0000000"; when "1001" => return "0010000";
            when "1010" => return "0001000"; when "1011" => return "0000011";
            when "1100" => return "1000110"; when "1101" => return "0100001";
            when "1110" => return "0000110"; when "1111" => return "0001110";
            when others => return "1111111";
        end case;
    end function;
begin
    process(CLOCK_50)
    begin
        if rising_edge(CLOCK_50) then
            if KEY(0) = '0' then
                div_count <= (others => '0');
                slow_clk <= '0';
            elsif div_count = TODO_DIVIDER_LIMIT then
                div_count <= (others => '0');
                slow_clk <= not slow_clk;
            else
                div_count <= div_count + 1;
            end if;
        end if;
    end process;

    process(slow_clk, KEY)
    begin
        if KEY(0) = '0' then count <= (others => '0');
        elsif rising_edge(slow_clk) then count <= TODO_NEXT_COUNT;
        end if;
    end process;

    LEDR(3 downto 0) <= TODO_LED_COUNT;
    LEDR(9 downto 4) <= (others => '0');
    HEX0 <= TODO_HEX_COUNT;
end architecture rtl;

Construye el contador en la placa real, observa cómo sube, resetéalo y prueba los dos valores alternativos de divisor.

Sube tu evidencia. Espera un momento en que HEX0 muestre el dígito C (decimal 12), captura una imagen de la cámara (LEDR(3 downto 0) debe leer 1100 al mismo tiempo) y adjúntala abajo.

Un contador normal de 4 bits recorre 0-15 y muestra A-F en los seis valores superiores. Muchos displays reales quieren un único dígito decimal: contar 0, 1, 2, ..., 9 y volver directamente a 0. Un contador que cuenta solo 0-9 se llama BCD (*binary-coded decimal*).

El cambio es pequeño: en vez de dejar que el registro de 4 bits vuelva solo a 0 después de 15, detectas cuando la cuenta llega a 9 y fuerzas el siguiente valor a 0. Reemplaza el proceso del contador por esta forma:

process(slow_clk, KEY)
begin
    if KEY(0) = '0' then count <= TODO_RESET_COUNT;
    elsif rising_edge(slow_clk) then
        if count = TODO_LAST_BCD_DIGIT then count <= TODO_WRAP_VALUE;
        else                              count <= TODO_NEXT_COUNT;
        end if;
    end if;
end process;

Deja todo lo demás igual: divisor, asignaciones a LEDR/HEX0 y función seg. Ahora HEX0 debe recorrer 0 a 9 y nunca mostrar A-F.

Un registro de desplazamiento es una fila de biestables donde, en cada flanco de reloj, cada bit se mueve a su vecino y un bit nuevo entra por un extremo. Es la base de cómo funcionan muchos enlaces seriales: protocolos como UART, SPI e I2C envían datos bit a bit, y un registro de desplazamiento ensambla esos bits en un byte o separa un byte en bits.

El diseño de abajo es un registro de 8 bits shreg(7 downto 0). En cada flanco de subida de slow_clk, mientras el desplazamiento está habilitado, hace:

shreg <= TODO_SHIFT_LEFT_UPDATE;  -- TODO: shift left and bring SW(0) into bit 0

Lee con cuidado el lado derecho: toma los siete bits bajos shreg(6 downto 0), los mueve una posición hacia arriba e introduce SW(0) en el bit 0. Cada bit se mueve hacia el extremo alto, así que es un desplazamiento a la izquierda. Controles: SW(0) = bit serial que entra, KEY(0) = reset (activo en bajo), KEY(1) = habilitación de desplazamiento (activa en bajo: mantén KEY(1) pulsado para desplazar en cada tick).

Patrón esperado. Razónalo en vez de confiar en la orientación de la cámara. Empieza en 0000_0000. Pon SW(0) = 1 y deja pasar cuatro ticks: el registro se llena desde el bit 0 hacia arriba, dando 0000_0001, luego 0000_0011, 0000_0111, 0000_1111. Ahora pon SW(0) = 0 y deja pasar cuatro ticks más: entran ceros por el bit 0 y empujan los unos hacia arriba y fuera, dando 0001_1110, 0011_1100, 0111_1000 y finalmente 1111_0000. Así que después de cuatro 1 seguidos de cuatro 0, shreg(7 downto 0) es 1111_0000.

Valor de bits frente a lo que ves. Registra ambas cosas: el valor binario del registro y lo que muestra la cámara. El orden físico de los LED en la placa puede verse espejado respecto a cómo escribes los bits (shreg(7) en un lado, shreg(0) en el otro), así que los LED encendidos pueden parecer invertidos de izquierda a derecha frente al número 1111_0000. Eso es un efecto de etiqueta/orientación, no un error lógico: por eso anotarás el valor calculado junto a la foto.

-- Plantilla de estudiante: completa las lineas TODO antes de sintetizar.
-- Lección 4 - Ejercicio 2-D: registro de desplazamiento de 8 bits hacia la izquierda.
-- SW(0)=dato serie de entrada, KEY(0)=reset, KEY(1)=habilitar desplazamiento. Las entradas KEY son activas en bajo.
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.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
    constant DIV : unsigned(26 downto 0) := TODO_VISIBLE_DIVIDER;
    signal div_count : unsigned(26 downto 0) := (others => '0');
    signal slow_clk  : std_logic := '0';
    signal shreg     : std_logic_vector(7 downto 0) := (others => '0');
begin
    process(CLOCK_50)
    begin
        if rising_edge(CLOCK_50) then
            if KEY(0) = '0' then
                div_count <= (others => '0'); slow_clk <= '0';
            elsif div_count = DIV then
                div_count <= (others => '0'); slow_clk <= not slow_clk;
            else
                div_count <= div_count + 1;
            end if;
        end if;
    end process;

    process(slow_clk, KEY)
    begin
        if KEY(0) = '0' then
            shreg <= (others => '0');
        elsif rising_edge(slow_clk) then
            if KEY(1) = '0' then shreg <= TODO_SHIFT_UPDATE;
            end if;
        end if;
    end process;

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

Construye el registro de desplazamiento y observa cómo un LED encendido avanza por la fila; después observa cómo lo siguen los ceros.

Sube tu evidencia. Tras cuatro ticks con SW(0)=1 y cuatro ticks con SW(0)=0, suelta KEY(1) para congelar el patrón (shreg = 1111_0000), captura una imagen de la cámara, anota si los LED parecen espejados y adjunta la captura abajo.

Desplaza en el otro sentido. Para hacer que el registro se desplace a la derecha en vez de a la izquierda, cada bit se mueve hacia el extremo bajo y el nuevo bit entra por arriba (shreg(7)). Solo cambia una línea. Sustituye la asignación de desplazamiento por:

shreg <= TODO_SHIFT_RIGHT_UPDATE; -- TODO: shift right and bring SW(0) into bit 7

Solo cambia esa línea. Ahora SW(0) entra en shreg(7), y los siete bits altos shreg(7 downto 1) bajan hacia shreg(6 downto 0).

Extensión: contador en anillo. Un contador en anillo realimenta la propia salida del registro hacia su entrada, de modo que un patrón fijo circula sin fin. Haz un anillo con desplazamiento a la izquierda que realimente el bit superior shreg(7) hacia el bit 0, e inicializa el registro a 0000_0001 para que un único LED encendido persiga al resto por la fila. Usa un reset que cargue "00000001" (no "00000000") y una línea de desplazamiento shreg <= shreg(6 downto 0) & shreg(7);. Mantén KEY(1) y observa cómo un LED gira continuamente.