Contadores asíncronos

01 · Punto de partida

Contar con flip-flops

Ya sabés dos cosas que alcanzan para armar un contador. Primero, que un flip-flop con D conectada a ~Q conmuta en cada flanco y divide la frecuencia por dos (temas 9 y 12). Segundo, que un registro de n flip-flops puede representar 2ⁿ valores. Falta unir las dos ideas: si la salida de una etapa se usa como reloj de la siguiente, cada etapa cambia a la mitad de la velocidad de la anterior, y el conjunto recorre los números en binario.

En el taller del tema 12 armaste uno de dos bits. Este tema lo generaliza a n bits, estudia lo que ocurre en los instantes entre un estado y el siguiente y muestra cuándo conviene y cuándo no usar este tipo de contador. Se llama asíncrono porque sus flip-flops no comparten el mismo reloj: cada uno recibe como reloj la salida del anterior.

02 · Estructura

La cadena ripple

Cada etapa es un flip-flop que conmuta (T = 1, o D = ~Q). El reloj externo entra a la primera; la salida Q de cada etapa va al reloj de la siguiente. Para que la secuencia sea ascendente, los flip-flops deben conmutar en el flanco descendente: así la etapa i+1 cambia justo cuando Q_i pasa de 1 a 0, que es el momento del «acarreo» de la suma binaria.

Qué cuenta y a qué frecuencia

Cada etapa divide por dos la frecuencia de la anterior. Con un reloj de frecuencia f, la salida Q_k tiene frecuencia f / 2^k+1 y ciclo de trabajo 50 %. El contador de n etapas recorre 2ⁿ estados antes de repetirse (módulo 2ⁿ):

Con f = 1 MHz: Q0 = 500 kHz, Q1 = 250 kHz, Q2 = 125 kHz. La última etapa nos da el reloj dividido por 2ⁿ. Esa es la propiedad que usan los divisores de frecuencia.

03 · Sentido

Contar hacia arriba y hacia abajo

Dos decisiones de cableado fijan el sentido: en qué flanco conmutan los flip-flops y qué salida se usa como reloj de la etapa siguiente (Q o ~Q). Hay cuatro combinaciones, y solo se trata de recordar que la etapa siguiente debe moverse cuando la anterior produce el acarreo (ascendente) o el préstamo (descendente).

Las dos primeras filas y las dos últimas son pares equivalentes: invertir la señal de reloj o cambiar de flanco da el mismo resultado. En un contador descendente la cuenta pasa de 0 a su valor máximo (en 3 bits, de 000 a 111) y después baja uno a uno. Es útil como «cuenta regresiva»: se carga un valor y se espera a que llegue a 0.

04 · El precio del ripple

Retardo acumulado y estados falsos

El defecto del ripple es que las etapas cambian una detrás de otra. Cada flip-flop tarda su tiempo de propagación t_pd en responder a su reloj, y recién entonces dispara a la siguiente. El efecto se acumula: en el peor caso, cuando el acarreo recorre toda la cadena, el contador necesita n · t_pd para asentarse.

Veamos el caso clásico, el paso de 7 a 8 (0111 → 1000) en un contador de 4 bits, con t_pd = 12 ns. Todos los bits tienen que cambiar, y lo hacen en orden:

Durante 48 ns, las salidas muestran tres valores que nunca fueron contados. Si algo mira el contador en ese intervalo, lee 6, 4 o 0 en lugar de 8. En un reloj de 1 MHz (período 1 µs) es irrelevante; a 10 MHz (100 ns) ya pesa.

Con t_pd = 12 ns y 15 ns de margen para quien lee, 4 etapas admiten alrededor de 16 MHz de lectura confiable, 8 etapas unos 9 MHz, y 16 etapas unos 5 MHz. Cuantas más etapas, más lento: ésa es la limitación estructural del ripple.

05 · Módulo N

Módulo N con clear asíncrono

¿Y si se quiere contar solo de 0 a 9, o de 0 a 5? El truco clásico usa el clear asíncrono de los flip-flops (tema 10): se detecta con una compuerta el primer valor que no debería existir y se lo usa para borrar el contador. Para módulo 10, el contador sube hasta 1010 (Q3 = 1 y Q1 = 1) y esa condición dispara el clear:

Funciona, pero con costos que conviene entender:

• El estado «prohibido» existe, brevemente. El 10 aparece en las salidas durante t_NAND + t_clear (por ejemplo 8 + 15 = 23 ns). Q1 y Q3 muestran un pulso falso de ese ancho: no se puede conectar a ellos algo sensible a pulsos cortos (otro contador, un disparo).
• El borrado es una carrera. Si los flip-flops no se borran todos con la misma rapidez, uno se resetea antes, la condición de detección desaparece y los demás quedan sin borrar. Por eso a veces se añade un latch SR que mantiene el clear hasta completarlo.
• El módulo no es una potencia de dos: la salida más alta ya no tiene ciclo de trabajo del 50 %. En módulo 10, Q3 está en alto 2 de cada 10 pulsos.
• Sentido único. Esta técnica sirve para contadores ascendentes; el módulo de uno descendente se resuelve cargando un valor.

En los temas 18 y 19 vamos a hacer lo mismo con contadores síncronos, donde todos los bits cambian a la vez y el módulo N se consigue sin estados falsos. Mientras tanto, esta técnica es útil cuando solo se necesita una salida de frecuencia (el borrado es rápido y a nadie le importa el pulso falso).

06 · Aplicaciones

División de frecuencia y temporización

La aplicación estrella del contador ripple es obtener frecuencias bajas a partir de una alta, de forma exacta y sin ajustes. Si la entrada es un cristal, la salida hereda su precisión.

El cristal de reloj: 32 768 Hz a 1 Hz

Los cristales de los relojes de pulsera oscilan a 32 768 Hz = 2¹⁵. No es casualidad: quince etapas dividen exactamente por 32 768 y entregan 1 Hz con el 50 % de ciclo de trabajo. Todo reloj digital de bajo costo usa esa cadena.

Contador como temporizador

Si se pone en marcha un contador desde cero con un reloj conocido, el instante en que un bit determinado sube marca un tiempo. Con un reloj de 1 MHz, el bit Q11 sube a los 2048 µs ≈ 2 ms y Q15 a los 32,8 ms. Si ese bit se usa para detener el contador o para disparar otro circuito, se obtiene un retardo ajustable por el bit elegido. Es un temporizador digital: más estable que el RC del 555 (tema 32), aunque con pasos de potencia de dos.

07 · Componentes

Contadores reales: 393, 4040 y 4060

No hace falta armar la cadena con flip-flops sueltos: existen contadores ripple integrados, pensados para dividir.

Observá que son todos de flanco descendente y con reset en alto (al revés del CLR̅ de los 74HC74). El 4060 es el favorito de los relojes: con un cristal de 32,768 kHz entre sus pines de oscilador, la salida Q14 entrega 32 768 / 2¹⁴ = 2 Hz, y con un flip-flop T más se llega a 1 Hz.

08 · El contador en código

Simular la cadena, el sentido, el módulo y los tiempos

Los bloques reproducen la propagación etapa por etapa para ver los estados falsos, comparan el contador ascendente con el descendente, reconstruyen el módulo N con clear asíncrono y calculan divisores y frecuencias máximas.

Paso 1: la propagación y los estados falsos

class Ripple:
    """Contador asíncrono de n etapas con flip-flops que conmutan en el flanco descendente de su reloj."""

    def __init__(self, n=4, tpd=12):
        self.n, self.tpd = n, tpd
        self.q = [0] * n                      # q[0] = bit menos significativo

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

    def pulso(self, t0=0):
        """Devuelve la lista de (tiempo en ns, estado) que se ve en las salidas tras un flanco de reloj."""
        eventos, t = [], t0
        for i in range(self.n):
            t += self.tpd                      # cada etapa espera a la anterior
            self.q[i] ^= 1
            eventos.append((t, self.valor()))
            if self.q[i] == 1:                 # subió: no hay flanco descendente para la etapa siguiente
                break
        return eventos


r = Ripple(4, tpd=12)
for _ in range(7):
    r.pulso()
print("el contador está en", f"{r.valor():04b}", "(7)")
print("llega el pulso 8; lo que ven las salidas:")
eventos = r.pulso()
for t, v in eventos:
    print(f"  t = +{t:2d} ns  ->  {v:04b}  ({v})")
print("estados falsos intermedios:", *(f"{v:04b}" for _, v in eventos[:-1]))
print(f"tiempo hasta el estado correcto: {eventos[-1][0]} ns")

El pulso 8 dispara cuatro cambios sucesivos, separados por 12 ns: 0110 (6), 0100 (4), 0000 (0) y recién a los 48 ns 1000 (8). Los tres primeros son estados falsos. Cambiá tpd y el número de etapas: el tiempo hasta el estado correcto es siempre n · t_pd en el peor caso. Con un pulso que solo cambia Q0 (por ejemplo, de 2 a 3), el asentamiento es de 12 ns.

Paso 2: ascendente y descendente

def contar(n, pulsos, fuente):
    """fuente = 'q': cada etapa se dispara con Q de la anterior; 'qn': con Q negada."""
    q = [0] * n
    secuencia = [sum(b << i for i, b in enumerate(q))]
    src = lambda i: q[i] if fuente == "q" else 1 - q[i]
    for _ in range(pulsos):
        antes = [src(i) for i in range(n)]
        q[0] ^= 1                                     # el reloj externo llega a la etapa 0
        for i in range(1, n):
            ahora = src(i - 1)
            if antes[i - 1] == 1 and ahora == 0:      # flanco descendente en el reloj de la etapa i
                antes[i] = src(i)
                q[i] ^= 1
            else:
                break
        secuencia.append(sum(b << i for i, b in enumerate(q)))
    return secuencia


print("fuente Q  (sube):", *contar(3, 8, "q"))
print("fuente Q̅  (baja):", *contar(3, 8, "qn"))

Con Q como reloj de la etapa siguiente, la secuencia es 0 1 2 3 4 5 6 7 0. Con ~Q, la misma cadena cuenta 0 7 6 5 4 3 2 1 0: baja. El cambio de un cable invierte el sentido. Probá con 4 etapas y 16 pulsos para ver el ciclo completo.

Paso 3: módulo N con clear asíncrono

tpd_nand, tpd_clear = 8, 15                 # ns: la compuerta que detecta y el borrado del flip-flop


def contador_modn(N, n=4, pulsos=None):
    pulsos = pulsos or 2 * N
    v, filas = 0, []
    for k in range(pulsos):
        v += 1
        if v == N:                                    # aparece N, se detecta y se borra
            filas.append((v, "transitorio", tpd_nand + tpd_clear))
            v = 0
        filas.append((v, "estable", None))
    return filas


for N in (6, 10):
    filas = contador_modn(N)
    estables = ["0"] + [f"{v}" for v, tipo, _ in filas if tipo == "estable"][:N + 1]
    glitch = [(v, d) for v, tipo, d in filas if tipo == "transitorio"][0]
    unos = [f"Q{i}" for i in range(4) if (N >> i) & 1]
    print(f"MOD-{N}: secuencia estable {' '.join(estables)}")
    print(f"   estado transitorio {glitch[0]} ({glitch[0]:04b}) dura unos {glitch[1]} ns; las salidas {', '.join(unos)} dan un pulso falso de ese ancho")

El módulo 6 cuenta 0 1 2 3 4 5 y vuelve a 0; el módulo 10 cuenta de 0 a 9. En ambos aparece un estado transitorio (6 = 0110 o 10 = 1010) de unos 23 ns, y las salidas que valen 1 en ese estado (Q1 y Q2 en el módulo 6; Q1 y Q3 en el módulo 10) producen un pulso falso de ese ancho. Si alguna de esas salidas alimenta a otro contador, éste cuenta un pulso de más.

Paso 4: divisores y frecuencia máxima

f_cristal = 32768
etapas = 15
print(f"{f_cristal} Hz dividido por 2^{etapas} = {f_cristal / 2 ** etapas:g} Hz")
print()
print("divisores sucesivos de 1 MHz:")
for k in (1, 2, 4, 8, 12, 16, 20):
    f = 1_000_000 / 2 ** k
    T = 1 / f
    print(f"  /{2 ** k:>8,}  f = {f:>12,.3f} Hz   período = {T * 1e6:>13,.1f} us")
print()
tpd, margen = 12, 15                      # ns por etapa y margen para leer
print("frecuencia máxima de conteo confiable (lectura estable):")
for n in (4, 8, 12, 16):
    t = n * tpd + margen
    print(f"  {n:2d} etapas: {t:3d} ns de asentamiento -> {1e3 / t:6.1f} MHz")

32 768 Hz entre 2¹⁵ da 1 Hz exacto. De 1 MHz, doce etapas dan 244,14 Hz (período de 4,096 ms) y veinte etapas, 0,954 Hz. Para leer el contador como número, la frecuencia máxima baja con las etapas: 15,9 MHz con 4 etapas, 9,0 MHz con 8, 6,3 MHz con 12 y 4,8 MHz con 16 (con t_pd = 12 ns y 15 ns de margen). Un divisor de 20 etapas puede trabajar a una frecuencia alta si solo se mira la última salida.

Los cuatro resultados muestran la misma lección desde ángulos distintos: el ripple es excelente para dividir y mediocre para leer, y su módulo N depende de una carrera entre compuertas.

09 · Exploración interactiva

El laboratorio: contador ripple

El simulador reproduce un contador de 2 a 8 etapas. Elegís el número de bits, el sentido, el retardo por etapa y, opcionalmente, un módulo N (con borrado asíncrono). Cada pulso muestra la secuencia de estados que atraviesan las salidas, el tiempo de asentamiento y qué valor lee un circuito que mire el contador a un tiempo fijo después del flanco (el control «Leer a los»). Con la frecuencia del reloj se comprueba si el contador alcanza a asentarse antes del pulso siguiente.

Recorrido guiado

1. Con 4 etapas, ascendente y t_pd = 12 ns, presioná «Pulso de reloj» siete veces y observá la tabla. Los primeros pulsos tardan 12 ns (solo cambia Q0); el pulso 2 tarda 24 ns (Q0 baja y arrastra a Q1).
2. Dale el pulso 8: pasa por 0110, 0100 y 0000 antes de llegar a 1000, y asienta a los 48 ns. Con «Leer a los» = 30 ns la lectura es 0100 (4): lectura incorrecta.
3. Subí «Leer a los» a 60 ns: ahora la lectura coincide. Es la regla del tema: leer después de n · t_pd.
4. Subí el retardo por etapa a 30 ns: el pulso 8 tarda 120 ns. Con el reloj de 10 MHz (100 ns), «¿Asienta antes del siguiente pulso?» pasa a «No»: la cuenta empieza a perderse.
5. Cambiá a descendente: la cuenta arranca en 0000 → 1111 → 1110 → … y cada paso baja uno. La propagación es igual, pero con los valores invertidos.
6. Con 4 etapas ascendente, escribí módulo 10 y repetí hasta el pulso 10: la secuencia pasa por 1010 y se borra (y la lectura a 30 ns todavía alcanza a ver 1010, el estado prohibido). Con «Leer a los» = 60 ns lee 0000.
7. Subí a 8 etapas, con t_pd = 12 ns y reloj de 10 MHz: el peor caso (127 → 128) tarda 96 ns, que roza el período de 100 ns. Con t_pd = 15 ns ya no entra.
8. Mirá «Frecuencia de la salida más lenta»: con 8 etapas y 1 MHz son 3906,25 Hz. Con módulo 10 es 100 kHz, pero ya sin ciclo de trabajo del 50 %.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Predecí antes de simular

1. Tiempo de asentamiento

Un contador ripple de 8 etapas con t_pd = 12 ns y 15 ns de margen de lectura. ¿Cuánto tarda en asentarse en el peor caso y cuál es la frecuencia máxima de lectura confiable?

2. Frecuencias del 74HC4040

Un 74HC4040 recibe 1 MHz. ¿Qué frecuencia y período tiene Q1 y Q12?

3. Módulo 12

Se quiere un contador módulo 12 (0 a 11) con clear asíncrono. ¿Qué estado se detecta y con qué salidas? ¿Qué salidas dan un pulso falso?

4. Cuenta descendente

Un contador descendente de 4 bits está en 0010. ¿Qué valor tiene después de 1, 2 y 3 pulsos?

5. De 32 768 Hz a 1 Hz

Con un 74HC4060 y un cristal de 32,768 kHz, ¿qué salida da 2 Hz y qué falta para llegar a 1 Hz?

6. Diagnóstico

Un contador de 8 bits con un reloj de 10 MHz y t_pd = 12 ns muestra valores absurdos justo en los pasos 127 → 128 y 255 → 0, pero anda bien el resto. ¿Qué explica el patrón y cómo se arregla?

12 · Síntesis

Ideas para recordar

¿Listo para el tema 18?

Antes de avanzar, explicá de memoria por qué un contador ripple pasa por estados falsos, cuánto tarda en asentarse y para qué usos sigue siendo una buena elección. Si podés justificar las tres respuestas, ya podés ver cómo se resuelven estos problemas con un reloj común.

En el próximo tema veremos los contadores síncronos: todos los flip-flops comparten el mismo reloj y un poco de lógica decide cuáles deben conmutar, de modo que los bits cambian a la vez, sin estados falsos y con velocidad independiente del número de etapas.