Contadores síncronos

01 · Punto de partida

Del ripple al reloj común

Los problemas del contador asíncrono nacen de un solo hecho: cada etapa espera a la anterior. El flanco del reloj entra por la primera y se «propaga» a lo largo de la cadena. Si todos los flip-flops recibieran el reloj al mismo tiempo, los bits cambiarían juntos, sin estados falsos, y el tiempo de asentamiento sería el de un solo flip-flop, sin importar el número de etapas.

Para lograrlo falta resolver una pregunta: si todos reciben cada flanco, ¿cómo evitamos que todos conmuten? La respuesta es la misma que en el registro con habilitación del tema 13: se pone lógica delante de cada entrada D (o T) que decide, antes del flanco, si esa etapa debe cambiar o retener. El flip-flop sigue capturando en cada flanco, pero lo que captura es o su propio valor o el contrario.

02 · Principio

Qué flip-flops deben conmutar

Mirá la secuencia binaria del tema 17. Un bit cambia en un flanco cuando todos los bits menos significativos valen 1: el bit 0 cambia siempre, el bit 1 cuando Q0 = 1, el bit 2 cuando Q0 = Q1 = 1, y así sucesivamente. Es la regla del acarreo de la suma binaria. En forma de ecuaciones, para un contador ascendente con habilitación EN:

Cada flip-flop recibe el mismo reloj y su entrada T (toggle) decide si conmuta en ese flanco. Con flip-flops D, la entrada vale D_i = Q_i ⊕ T_i (si T = 0 se copia a sí mismo, si T = 1 se invierte). Con flip-flops JK basta J = K = T (tema 9).

El esquema muestra la idea: una compuerta AND por etapa, que recibe la habilitación y las salidas de las etapas anteriores. Los cuatro flip-flops se disparan con el mismo flanco. Veamos qué valen las entradas T en cada estado:

En el paso 0111 → 1000, que en el ripple pasaba por 0110, 0100 y 0000, el síncrono cambia los cuatro bits en el mismo flanco. No hay estados intermedios (más allá de diferencias mínimas de retardo entre flip-flops).

03 · Velocidad

Acarreo y frecuencia máxima

El síncrono no elimina la cadena de acarreo: la mueve. Las compuertas AND necesitan tiempo para producir T_i a partir de las Q, y ese tiempo tiene que transcurrir antes del siguiente flanco. Es el mismo razonamiento de camino crítico del tema 13: el período mínimo es t_pd del flip-flop + retardo de la lógica de acarreo + t_setup.

El retardo del acarreo depende de cómo se arme la lógica:

• Acarreo en serie: cada AND recibe la salida de la anterior (T_i = T_i−1 · Q_i−1). Es el circuito más barato: una AND de 2 entradas por etapa. El retardo crece con n: (n − 2) compuertas en el peor caso.
• Acarreo en paralelo (look-ahead): cada T_i se calcula con una AND de i entradas que mira directamente las Q. El retardo crece apenas con el logaritmo de n.

Con 4 bits la diferencia es modesta; con 16 bits, el síncrono en paralelo trabaja casi 4 veces más rápido que el ripple, y lo que es más importante: las salidas son confiables en todo instante después de t_pd. Los contadores integrados llevan el acarreo de 4 bits resuelto dentro del chip, y las cascadas se hacen con las señales ENT y RCO, que vienen a continuación.

04 · Control

Habilitación, RCO y cascada

La habilitación EN del contador ya la conocés del tema 13: con EN = 0 todas las T valen 0, ningún flip-flop conmuta y el contador retiene su valor aunque el reloj siga corriendo. Es la forma limpia de «pausar» un contador, sin tocar el reloj. En el 74HC161 hay dos habilitaciones (ENP y ENT, o CEP y CET según el fabricante) y una salida de acarreo, RCO (o TC, terminal count).

Para armar un contador de 8 bits con dos chips, el RCO del primero se conecta al ENT del segundo, y los dos comparten el reloj y ENP. El segundo chip cuenta únicamente cuando el primero está en 15, es decir, en el instante en que habría un acarreo. Los dos reciben el mismo flanco, y los 8 bits se comportan como un único contador síncrono:

05 · Sentido

Ascendente, descendente y reversible

Cambiar de sentido es cambiar las condiciones de conmutación. Un contador descendente resta uno; un bit cambia cuando todos los menos significativos valen 0 (el «préstamo»):

Un contador reversible (up/down) tiene una entrada de sentido U/D̅ que elige cuál de las dos ecuaciones usa. Para cada etapa, un selector escoge entre Q y Q̅ del bit anterior. El contador integrado 74HC191 tiene esa entrada de sentido (D/U̅); el 74HC193 prefiere dos relojes separados, uno para subir y otro para bajar.

Un detalle práctico: el sentido no debe cambiar cerca del flanco de reloj. La entrada U/D̅ participa de las ecuaciones T, así que debe respetar el setup y el hold como cualquier dato. Un cambio de sentido en pleno flanco puede producir un salto inesperado. En los contadores integrados el fabricante especifica un tiempo de setup para esta entrada.

Desbordamiento y subdesbordamiento

Un contador ascendente de n bits pasa de 2ⁿ − 1 a 0 (overflow), y uno descendente de 0 a 2ⁿ − 1 (underflow). La salida RCO sirve para detectar estos pasos y encadenar contadores: ya no es solo un «acarreo» sino un aviso de «valor terminal».

06 · Carga y clear

Carga y clear: síncronos y asíncronos

Casi todos los contadores integrados permiten forzar un valor. Hay dos maneras de hacerlo y la diferencia es la misma que vimos en el tema 10: ¿actúa sin reloj, o espera el flanco?

La carga síncrona es la herramienta de diseño preferida: el valor se carga en un flanco bien definido, sincronizado con el resto del sistema, y los pulsos falsos en la línea de control quedan ignorados. El clear asíncrono es más rápido pero tiene los defectos del tema 17: un estado falso puede borrar el contador cuando no corresponde. En el tema 19 vamos a usar la carga síncrona para hacer contadores de módulo N sin estados prohibidos.

07 · Componentes

Contadores reales: 161, 163, 191 y 193

El par 161 y 163 es instructivo: son idénticos salvo en el clear. En el 161 el clear es asíncrono (actúa de inmediato); en el 163 es síncrono (espera el flanco). El 163 es preferible cuando el clear viene de lógica que puede tener pulsos falsos. Existen también las versiones decimales (74HC160 y 162, que cuentan 0 a 9), que veremos en el tema 19.

08 · El contador síncrono en código

Ecuaciones T, tiempos, cascada y controles

Los bloques implementan el contador con las ecuaciones T, comparan su velocidad con la del ripple, arman una cascada de dos chips con RCO y ENT, y ejercitan habilitación, sentido, carga y clear en una misma secuencia.

Paso 1: el contador con ecuaciones T

class ContadorSincrono:
    """Contador síncrono de n bits: todos los flip-flops reciben el mismo reloj; T_i decide quién conmuta."""

    def __init__(self, n=4):
        self.n, self.q = n, [0] * n               # q[0] = LSB

    def valor(self):
        return sum(b << i for i, b in enumerate(self.q))

    def entradas_t(self, en=1, sube=True):
        t = []
        for i in range(self.n):
            previos = self.q[:i] if sube else [1 - b for b in self.q[:i]]
            t.append(en & int(all(previos)))      # T_i = EN · (Q0·Q1·...·Q_{i-1})  [o con Q negadas al bajar]
        return t

    def flanco(self, en=1, sube=True):
        t = self.entradas_t(en, sube)             # se calculan ANTES del flanco, con el estado actual
        self.q = [b ^ ti for b, ti in zip(self.q, t)]
        return t


c = ContadorSincrono(4)
print("pulso  Q3Q2Q1Q0   T3T2T1T0  (T = quién conmuta en este flanco)")
for k in range(1, 9):
    t = c.flanco()
    print(f"{k:3d}    {c.valor():04b}       {''.join(str(x) for x in reversed(t))}")
print()
print("con EN = 0 el contador retiene:", end=" ")
for _ in range(3):
    c.flanco(en=0)
print(f"{c.valor():04b}  ({c.valor()})")
print("contando hacia abajo desde", f"{c.valor():04b}:", end=" ")
secuencia = []
for _ in range(10):
    c.flanco(sube=False)
    secuencia.append(c.valor())
print(*secuencia)

La tabla muestra, para cada pulso, el estado nuevo y las T que valían antes del flanco: en el pulso 4 conmutan Q2, Q1 y Q0 (T = 0111), y en el pulso 8 los cuatro (T = 1111). Con EN = 0 el contador queda en 1000 (8) aunque lleguen tres flancos. Cambiando sube a falso, la cuenta pasa por 7 6 5 4 3 2 1 0 y da la vuelta a 15, 14. Cambiá n para ver contadores de más bits.

Paso 2: velocidad frente al ripple

from math import ceil, log2

tpd, t_and, t_su, margen = 12, 8, 10, 15      # ns

print(" n   ripple (asienta)   sinc. acarreo serie   sinc. acarreo paralelo")
for n in (4, 8, 12, 16):
    ripple = n * tpd + margen
    serie = tpd + (n - 2) * t_and + t_su
    paralelo = tpd + ceil(log2(max(n - 1, 2))) * t_and + t_su
    print(f"{n:2d}   {1e3 / ripple:5.1f} MHz ({ripple:3d} ns)   {1e3 / serie:5.1f} MHz ({serie:3d} ns)    {1e3 / paralelo:5.1f} MHz ({paralelo:3d} ns)")

print()
print("estados falsos en 0111 -> 1000:")
print("  ripple     : 0110, 0100, 0000 (3 estados falsos, 48 ns hasta 1000)")
print(f"  sincrono   : ninguno; los 4 bits cambian juntos {tpd} ns despues del flanco")

Con 4 bits, el síncrono admite 26,3 MHz frente a 15,9 MHz del ripple. Con 16 bits, el ripple cae a 4,8 MHz y el síncrono con acarreo en paralelo se mantiene en 18,5 MHz; con acarreo en serie baja a 7,5 MHz, porque la cadena de AND vuelve a ser larga. Todo el costo del síncrono está en la lógica de acarreo: si se la diseña bien, la velocidad casi no depende de n.

Paso 3: dos contadores en cascada con RCO y ENT

class Contador4:
    """Un 74HC161 simplificado: ENP y ENT habilitan; RCO = ENT · (Q = 1111)."""

    def __init__(self):
        self.q = 0

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

    def flanco(self, enp=1, ent=1):
        if enp and ent:
            self.q = (self.q + 1) & 15


bajo, alto = Contador4(), Contador4()
print("pulso  alto bajo   valor   RCO_bajo")
for k in range(1, 21):
    rco = bajo.rco(1)                     # RCO del primero va a ENT del segundo
    alto.flanco(enp=1, ent=rco)           # el alto cuenta solo si el bajo está en 15
    bajo.flanco()
    print(f"{k:3d}     {alto.q:04b} {bajo.q:04b}   {alto.q * 16 + bajo.q:3d}      {bajo.rco(1)}")

El conjunto cuenta 1, 2, 3 … 15 en el chip bajo; en el pulso 15 su RCO sube a 1, y en el flanco siguiente (pulso 16) el chip alto avanza a 0001 mientras el bajo vuelve a 0000, todo en el mismo flanco. Al llegar a 20, el valor es 0001 0100 = 20. La columna RCO muestra el valor después de cada pulso; el segundo chip usa el RCO anterior al flanco.

Paso 4: habilitación, sentido, carga y clear

class Contador:
    def __init__(self, n=4):
        self.n, self.v = n, 0

    def flanco(self, en=1, sube=True, carga=None, clr_n=1):
        if clr_n == 0:                         # clear asíncrono: actúa sin esperar al reloj
            self.v = 0
            return "clear"
        if carga is not None:                  # carga síncrona: tiene prioridad sobre el conteo
            self.v = carga & (2 ** self.n - 1)
            return f"carga {carga}"
        if en:
            self.v = (self.v + (1 if sube else -1)) % 2 ** self.n
            return "sube" if sube else "baja"
        return "retiene"


c = Contador(4)
acciones = [
    dict(), dict(), dict(), dict(en=0), dict(en=0), dict(sube=False), dict(sube=False),
    dict(carga=14), dict(), dict(), dict(), dict(clr_n=0), dict(sube=False),
]
print("accion        valor")
for a in acciones:
    texto = c.flanco(**a)
    print(f"{texto:12s}  {c.v:2d}  ({c.v:04b})")

La secuencia mezcla todos los controles: tres pulsos suben a 3, dos con EN = 0 retienen, dos con sentido descendente bajan a 1, la carga síncrona fuerza 14 (aunque el contador valiera 1), luego sube a 15, desborda a 0 y llega a 1; el clear lo deja en 0 sin esperar y un pulso descendente produce el subdesbordamiento 15. Probá cambiar el orden de las acciones.

Observá que en los cuatro bloques el estado se actualiza una sola vez por flanco, con los valores de antes del flanco. Es el modelo mental correcto: en el hardware, todo el contador «salta» de un estado al siguiente de una vez.

09 · Exploración interactiva

El laboratorio: contador síncrono

El simulador reproduce un contador síncrono de 4 bits, o de 8 bits como cascada de dos chips con RCO y ENT. Podés cambiar el sentido, quitar la habilitación y cargar un valor síncronamente. En el panel se ven las entradas T de cada etapa antes del flanco, qué flip-flops conmutaron (borde naranja) y los RCO. Además compara el tiempo de cambio con el de un contador ripple equivalente y las frecuencias máximas de ambos.

Recorrido guiado

1. Con 4 bits, ascendente y EN = 1, presioná «Pulso de reloj» varias veces y mirá T3..T0 antes de cada pulso: en 0000 vale 0001, en 0011 vale 0111, en 0111 vale 1111.
2. En el pulso 8 (0111 → 1000) conmutan los cuatro flip-flops a la vez. Mirá «Tiempo del ripple equivalente»: sería 4 · t_pd = 48 ns, y el síncrono tarda 12 ns.
3. Desmarcá EN y pulsá: todas las T valen 0 y el contador retiene. Volvé a marcarlo.
4. Cambiá a descendente: las T ahora usan las Q negadas. Desde 1000, el contador baja 0111, 0110, …; en 0000 baja a 1111, con los cuatro conmutando.
5. Marcá «LOAD̅ = 0» con 1110 y pulsá: el contador salta a 1110 en el flanco, sin importar el valor anterior. Desmarcá LOAD̅ y pulsá: sigue contando desde 14.
6. Presioná «CLR̅»: vuelve a 0 sin dar reloj. Compará con la carga, que necesita un flanco.
7. Marcá «Dos chips en cascada» y dale «8 pulsos» dos veces: al pasar de 15 a 16, RCO1 vale 1 antes del flanco y el segundo chip avanza en el mismo flanco.
8. Subí el t_pd a 30 ns: el síncrono sigue cambiando en 30 ns, mientras que el ripple equivalente, en el pulso 8 (0111 → 1000), tardaría 4 · 30 = 120 ns. Mirá cómo caen las frecuencias máximas.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Predecí antes de simular

1. Las T de un estado

Un contador síncrono ascendente de 4 bits (EN = 1) está en 0110. ¿Cuánto valen T3 T2 T1 T0 y cuál es el estado siguiente?

2. Frecuencia máxima

Un contador síncrono de 8 bits con acarreo en paralelo (3 niveles de AND de 8 ns), t_pd = 12 ns y setup de 10 ns. ¿Cuál es su frecuencia máxima? ¿Y la de un ripple de 8 etapas (margen 15 ns)?

3. Cascada de dos chips

Dos 74HC161 en cascada (RCO del primero a ENT del segundo) cuentan desde 0. Después de 100 pulsos, ¿qué valen el chip alto y el chip bajo? ¿Cuántas veces subió el RCO del primero?

4. Cuenta descendente

Un contador descendente de 4 bits está en 0100. ¿Cuánto valen T3 T2 T1 T0 y cuál es el estado siguiente?

5. Prioridad de la carga

Un 74HC161 está en 0101, con ENP = ENT = 1, LOAD̅ = 0 y entradas de datos 1110. ¿Cuánto vale después del próximo flanco? ¿Y si LOAD̅ se activa y se libera sin que haya flanco entre medio?

6. Diagnóstico

Dos contadores de 4 bits en cascada cuentan 00, 11, 22, 33, 44… (los dos nibbles avanzan siempre juntos). ¿Qué cableado erróneo lo explica?

12 · Síntesis

Ideas para recordar

¿Listo para el tema 19?

Antes de avanzar, escribí de memoria las ecuaciones T de un contador síncrono de 4 bits, explicá por qué desaparecen los estados falsos y decidí cómo se encadenan dos chips. Si podés justificar las tres respuestas, ya podés limitar la cuenta a un valor cualquiera.

En el próximo tema veremos los contadores módulo N y BCD: cómo hacer que el contador cuente de 0 a N − 1 (por ejemplo, de 0 a 9) usando la carga síncrona y el reset, y cómo encadenar décadas para mostrar números decimales.