Contadores módulo N y BCD

01 · Punto de partida

Cuando 16 no es el número

Un contador de n bits tiene 2ⁿ estados. Para recorrer solo N de ellos hay que decidir qué estado es el último y qué pasa después. Hay cuatro motivos habituales para necesitarlo:

• Mostrar números decimales: cada dígito es un contador de 0 a 9.
• Medir tiempo: segundos y minutos van de 0 a 59; las horas, de 0 a 23.
• Dividir una frecuencia por un número que no es potencia de dos (por ejemplo, por 10 o por 60).
• Recorrer una zona: direcciones de una memoria que no ocupa todo el espacio, o pasos de una secuencia.

El contador que limitamos puede ser asíncrono o síncrono, pero para que el resultado sea confiable conviene partir de un contador síncrono, que ya tiene los tres controles necesarios: clear, carga y habilitación (tema 18). Falta decidir con cuál de ellos se corta la cuenta.

02 · Técnicas

Tres técnicas para limitar la cuenta

Para un módulo N = 10 en un contador de 4 bits (que debe recorrer 0 a 9), estas son las tres formas de cortar la cuenta. Todas usan una compuerta que detecta un valor; lo que cambia es qué detecta y qué control acciona.

Clear asíncrono: ya lo conocés

Es la técnica del tema 17: se detecta el primer valor que no debería existir y se lo borra de inmediato. Es la más rápida de armar y la peor desde el punto de vista del diseño: el estado N sí aparece en las salidas durante t_detección + t_clear, y cualquier circuito que mire esas salidas puede interpretarlo. Además, el borrado es una carrera entre flip-flops. Solo se justifica para divisores donde el pulso falso no importa.

Clear síncrono: detectar el último, borrar en el flanco

Se detecta N − 1, el último valor legítimo, y se activa el clear síncrono (como el del 74HC163). Al llegar el siguiente flanco, en vez de sumar uno, el contador va a cero. El estado N nunca existe: el contador pasa de N − 1 a 0 directamente. Las únicas señales que viven fuera del ciclo son las de la lógica de detección, y esas se capturan en el flanco (setup y hold) como cualquier dato.

Para N = 10 se detecta 1001 con la compuerta que mira Q3 y Q0 (nadie antes de 1001 tiene ambos en 1): SR̅ = NAND(Q3, Q0). Para N = 6 se detecta 0101 (Q2 y Q0).

Carga síncrona: elegir dónde empieza

En vez de borrar, se carga un valor. El contador cuenta hacia arriba hasta su valor máximo (15), la salida RCO lo avisa y esa señal activa la carga: en el flanco siguiente, en lugar de pasar a 0, salta a 16 − N. Para N = 10 se carga 6: la secuencia es 6, 7, … 15, 6, 7 …, que son 10 estados. La ventaja es que el rango deja de empezar en cero: se puede contar de cualquier valor L hasta 15, con N = 16 − L, o hasta cualquier valor final detectando ese valor y cargando el inicial.

03 · Decimal

Contador BCD (década)

BCD (Binary Coded Decimal) representa cada dígito decimal con su propio grupo de 4 bits. El número 59 no es 111011 (binario) sino 0101 1001: un nibble para el 5 y otro para el 9. Es menos eficiente que el binario puro (4 bits pueden guardar 16 valores y BCD solo usa 10), pero tiene una gran ventaja práctica: cada nibble se puede enviar directamente a un decodificador de display de 7 segmentos (tema 20) sin ninguna conversión.

Un contador de década es un contador módulo 10 que recorre 0 a 9 y vuelve a 0, con la propiedad de que el paso de 9 a 0 produce una salida de acarreo (RCO) para la década siguiente. Se obtiene con cualquiera de las técnicas anteriores; el 74HC160 y el 74HC162 ya lo traen resuelto: son idénticos al 161 y al 163 (clear asíncrono y síncrono, respectivamente), pero cuentan 0 a 9. Su RCO vale ENT · Q3 · Q0 (el estado 9 = 1001).

De binario a BCD y al revés

Un número binario no se convierte a BCD por simple reagrupamiento de bits: hay que dividir entre 10 (o usar el algoritmo de «doble-dabble»). En cambio, pasar de BCD a número es multiplicar cada dígito por su peso: 0101 1001 = 5 · 10 + 9 = 59. Además, cualquier nibble mayor que 1001 indica un error: 0101 1100 no es un BCD válido.

04 · Varias cifras

Cascada de décadas

Para contar con más de una cifra se encadenan décadas de la misma manera que los contadores binarios del tema 18: el reloj es común y el RCO de cada década habilita (ENT) a la siguiente. La década de las decenas solo avanza cuando las unidades están en 9; la de las centenas, cuando unidades y decenas están en 99:

Cada década suma una cifra decimal. Con k décadas se cuenta de 0 a 10^k − 1. Si el RCO de la última década se lleva a un indicador, queda un aviso de desbordamiento («overflow») que un contador de eventos puede mostrar.

05 · Aplicación

Relojes: 59 y 23

Un reloj digital es una cascada de décadas con módulos mixtos. Cada par de dígitos tiene un módulo distinto:

Los minutos y los segundos son simples: unidades módulo 10, decenas módulo 6 y el RCO de las unidades habilitando a las decenas. Las horas tienen la dificultad de no ser un producto de módulos independientes: las unidades llegan a 9 (de 00 a 09 y de 10 a 19) pero solo hasta 3 en la decena 2. La solución es una compuerta que detecte el estado 23 (decenas = 0010, unidades = 0011) y borre ambas décadas en el flanco siguiente. Así 23:59:59 pasa a 00:00:00 sin que aparezca 24.

El pulso de entrada es una señal de 1 Hz. Un cristal de 32 768 Hz y 15 etapas de división (tema 17) la generan con precisión de cristal; de ahí en adelante, todo el reloj es una cadena de décadas y detectores.

06 · Divisores

Divisor por N con ciclo del 50 %

Un contador módulo N usado como divisor entrega una salida de frecuencia f / N, pero normalmente no simétrica. En módulo 10, el bit Q3 está en alto solo durante 8 y 9: 2 de cada 10 pulsos, un ciclo de trabajo del 20 %. Para algunas aplicaciones (generar un reloj, un tren de pulsos limpio, excitar una carga) hace falta un 50 %.

Si N es par, hay una solución simple: se divide por N/2 con el contador y luego se pasa la salida por un flip-flop T (que divide por dos). La salida del flip-flop cambia una vez cada N/2 pulsos y queda en alto exactamente la mitad del tiempo. Para dividir por 10: módulo 5 seguido de un divisor por 2.

Cuando N es impar no se puede lograr un 50 % exacto con flancos de un solo sentido (habría que usar los dos flancos del reloj). Si no es necesario, se acepta un ciclo asimétrico.

07 · Componentes

Contadores reales: 160 a 163

Los cuatro contadores síncronos de 4 bits de la familia 74HC comparten patillado y controles; difieren en la cuenta y en el tipo de clear:

Dos reglas prácticas: para relojes y contadores de eventos, el 162 y el 163 (clear síncrono) son los más seguros; para un módulo N cualquiera, el 161 o 163 con carga o clear síncrono. Para cualquiera de ellos conviene conectar las entradas de datos de carga a niveles fijos, aunque no se use la carga, para que no queden al aire.

08 · Módulo N y BCD en código

Comparar técnicas, encadenar décadas y armar un reloj

Los bloques ponen las tres técnicas lado a lado, simulan tres décadas en cascada, arman un reloj hh:mm:ss con módulos mixtos y resuelven conversiones BCD, rangos y divisores con 50 %.

Paso 1: las tres técnicas con módulo 10

def secuencia(tecnica, N, pulsos):
    v, vistos, prohibido = 0, [0], 0
    for _ in range(pulsos):
        if tecnica == "libre":
            v = (v + 1) & 15
        elif tecnica == "clear asincrono":
            v = (v + 1) & 15
            if v == N:                     # el estado N aparece un instante y se borra
                vistos.append(v)
                prohibido += 1
                v = 0
        elif tecnica == "clear sincrono":
            v = 0 if v == N - 1 else (v + 1) & 15      # se detecta N-1 y el borrado ocurre en el flanco siguiente
        elif tecnica == "carga sincrona":
            v = 16 - N if v == 15 else v + 1           # se detecta 15 (RCO) y se carga 16-N
        vistos.append(v)
    return vistos, prohibido


N = 10
for tecnica in ("libre", "clear asincrono", "clear sincrono", "carga sincrona"):
    s, p = secuencia(tecnica, N, 24)
    texto = " ".join(f"{x:X}" for x in s)
    print(f"{tecnica:16s} {texto}")
    print(f"{'':16s} estados prohibidos vistos: {p}")

La cuenta libre llega a F (15). El clear asíncrono intercala una A (10) antes de cada 0: son los dos «estados prohibidos vistos». El clear síncrono recorre 0 a 9 limpio. La carga síncrona hace un primer ciclo completo de 0 a F (arrancó en 0) y desde ahí cuenta 6 a F, que son 10 estados. Cambiá N a 6 o 12 y comprobá los resultados.

Paso 2: tres décadas en cascada

class Decada:
    """Un contador BCD tipo 74HC160/162: cuenta 0 a 9; RCO = ENT · (Q = 9)."""

    def __init__(self):
        self.q = 0

    def rco(self, ent):
        return int(ent and self.q == 9)

    def flanco(self, ent=1):
        if ent:
            self.q = (self.q + 1) % 10


def pulso(decadas):
    ent = 1
    ents = []
    for d in decadas:                      # unidades, decenas, centenas: el RCO de cada una habilita la siguiente
        ents.append(ent)
        ent = d.rco(ent)
    for d, e in zip(decadas, ents):
        d.flanco(e)


def bcd(decadas):
    return " ".join(f"{d.q:04b}" for d in reversed(decadas))


dec = [Decada(), Decada(), Decada()]
marcas = {9, 10, 11, 99, 100, 101, 999}
for k in range(1, 1001):
    pulso(dec)
    if k in marcas or k == 1000:
        valor = dec[2].q * 100 + dec[1].q * 10 + dec[0].q
        print(f"pulso {k:4d}: cuenta {valor:3d}   BCD {bcd(dec)}")

En el pulso 10 las unidades vuelven a 0000 y las decenas avanzan a 0001; en el 100 avanzan las tres (0001 0000 0000), todo en el mismo flanco. El pulso 999 deja las tres décadas en 1001 y el 1000 las lleva a cero: desborda. Los enables se calculan antes del flanco para que todas se muevan con el estado anterior.

Paso 3: un reloj de pared

MODS = [10, 6, 10, 6, 10, 3]        # unidades y decenas de segundos, minutos y horas


def tick(d):
    ent = 1
    for i, m in enumerate(MODS):
        if i == 4 and ent and d[5] == 2 and d[4] == 3:      # 23 -> 00: se borran ambos dígitos de la hora
            d[4] = d[5] = 0
            return
        rco = ent and d[i] == m - 1
        if ent:
            d[i] = (d[i] + 1) % m
        ent = rco


def texto(d):
    return f"{d[5]}{d[4]}:{d[3]}{d[2]}:{d[1]}{d[0]}"


d = [5, 5, 9, 5, 3, 2]              # 23:59:55  (unidades de segundo primero)
print("inicio", texto(d))
for _ in range(8):
    tick(d)
    print("  +1 s ->", texto(d))

Desde 23:59:55 el reloj sube 56, 57, 58, 59 y en el quinto pulso pasa a 00:00:00 sin mostrar 24:00:00, porque la detección de 23 borra ambos dígitos de la hora. Después sigue 00:00:01, 02 y 03. Probá arrancar en 12:59:58 o en 09:59:59 y verificá que los acarreos se propagan bien.

Paso 4: BCD, rangos y divisor con 50 %

def a_bcd(n):
    return " ".join(f"{int(c):04b}" for c in str(n))


def de_bcd(texto):
    nibbles = texto.split()
    if any(int(x, 2) > 9 for x in nibbles):
        return "BCD inválido (nibble mayor que 1001)"
    return int("".join(str(int(x, 2)) for x in nibbles))


for n in (7, 59, 99, 255):
    print(f"{n:3d} = binario {n:08b}  |  BCD {a_bcd(n)}")
print("de BCD '0101 1001' ->", de_bcd("0101 1001"))
print("de BCD '0101 1100' ->", de_bcd("0101 1100"))
print()

# Contar de 3 a 12 con carga síncrona (módulo 10 con arranque distinto de cero)
v, seq = 3, [3]
for _ in range(14):
    v = 3 if v == 12 else v + 1
    seq.append(v)
print("rango 3..12 (detecta 12, carga 3):", *seq)
print()

# Salida con 50 % de ciclo de trabajo: módulo 5 seguido de un flip-flop T
mod10 = [(k % 10) for k in range(20)]
q3 = [(x >> 3) & 1 for x in mod10]
mod5 = [(k % 5) for k in range(20)]
div2 = []
t = 0
for k, x in enumerate(mod5):
    if x == 0 and k > 0:
        t ^= 1
    div2.append(t)
print("Q3 del módulo 10   :", "".join(map(str, q3)), f"-> {sum(q3[:10]) * 10} % en alto")
print("módulo 5 + T       :", "".join(map(str, div2)), f"-> {sum(div2[:10]) * 10} % en alto (÷10)")

255 se escribe en BCD como 0010 0101 0101 (tres nibbles, no ocho bits); el nibble 1100 se detecta como inválido. El rango 3..12 tiene 10 estados y se logra detectando 12 y cargando 3. Q3 de un módulo 10 está en alto el 20 % del tiempo; un módulo 5 seguido de un flip-flop T da exactamente 50 % con la misma frecuencia de salida (÷10).

En los cuatro bloques el estado cambia una vez por flanco y las decisiones de acarreo y detección se toman con el estado anterior. Es el mismo modelo que el hardware, donde la lógica de control ve las salidas de antes del flanco.

09 · Exploración interactiva

El laboratorio: módulo N y relojes

El simulador tiene dos modos. En «Un contador de 4 bits» elegís la técnica (libre, clear asíncrono, clear síncrono o carga síncrona) y el módulo N (2 a 16), y mirás qué estados se visitan, cuántos estados prohibidos aparecen y cuál es el módulo realmente medido. En los otros modos se arman dos décadas BCD en cascada con módulos de reloj: 00–99, 00–59 (segundos o minutos) y 00–23 (horas).

Recorrido guiado

1. Con «Clear síncrono» y N = 10, dale «10 pulsos»: los estados vistos son 0 a 9 (10 estados) y los «estados prohibidos vistos» valen 0.
2. Cambiá a «Clear asíncrono» (se reinicia) y repetí con 10 pulsos: en el pulso 10 aparece la A (10) un instante antes de volver a 0 y el contador de estados prohibidos sube a 1. Cada vuelta suma uno.
3. Elegí «Carga síncrona» con N = 10 y dale «100 pulsos» sin más: el módulo medido da 16 porque el primer ciclo recorrió 0 a 15. Presioná «Reiniciar simulación», elegí otra vez «Carga síncrona», presioná «Valor inicial» (carga 6) y volvé a dar pulsos: ahora el módulo medido es 10, de 6 a 15.
4. Probá N = 6 con clear síncrono (0 a 5) y N = 12 con carga síncrona (valor inicial 4: 4 a 15). Comprobá en cada caso que la cantidad de estados vistos coincide con N.
5. Cambiá a «Dos décadas BCD: 00 a 99» y dale «10 pulsos»: aparece 10, con las unidades en 0 y las decenas en 1. Con «100 pulsos» pasa por 99 y vuelve a 00; los estados vistos llegan a 100.
6. Pasá a «00 a 59» y «100 pulsos»: el reloj llega a 59, pasa a 00 y sigue; los estados distintos son 60.
7. Pasá a «00 a 23» y dale «100 pulsos»: recorre 00 a 23 y vuelve a 00; el valor 24 nunca aparece, porque se detecta 23 y se borran ambas décadas. Con 100 pulsos queda en 04.
8. Mirá «Acarreo» en el modo de reloj: el RCO de las unidades solo vale 1 cuando están en 9, que es cuando las decenas avanzan en el próximo flanco.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Predecí antes de simular

1. Carga para módulo 12

Con un 74HC161 y carga síncrona, ¿qué valor se carga para obtener módulo 12 y qué estados recorre?

2. Clear síncrono para módulo 6

¿Qué valor se detecta y con qué compuerta se arma el clear síncrono de un contador módulo 6?

3. Rango 3 a 12

Se quiere contar de 3 a 12 (10 estados). ¿Qué se detecta, qué se carga y con qué compuerta?

4. Conversiones BCD

Escribí 87 en BCD y decidí qué número es 0100 0011 en BCD.

5. Cascada de tres décadas

Tres décadas en cascada cuentan desde 000. Después de 487 pulsos, ¿qué muestran en BCD? ¿Cuántas veces subió el RCO de las unidades y el de las decenas?

6. Diagnóstico

Un reloj muestra las horas 21, 22, 23, 24, 25 … 29 y recién después 00. ¿Qué falta en el diseño?

12 · Síntesis

Ideas para recordar

¿Listo para el tema 20?

Antes de avanzar, explicá de memoria por qué el clear síncrono evita el estado prohibido, cómo se encadenan dos décadas y por qué un reloj necesita detectar el 23. Si podés justificar las tres respuestas, ya podés contar eventos y mostrarlos en decimal.

En el próximo tema armaremos el taller del contador de eventos: un pulsador sin rebotes, un contador de décadas y un display de siete segmentos para mostrar el conteo decimal.