Contadores en anillo y Johnson

01 · Punto de partida

Un registro que se muerde la cola

Con el contador binario del tema 18, para saber «en qué paso estamos» hay que decodificar el número: un 4-a-16 para 16 pasos, y con cuidado de los estados falsos. A veces lo único que se necesita es una salida distinta por cada paso, que se active una a la vez y en orden. Para eso, el registro de desplazamiento del tema 14 alcanza: si se lo realimenta, el patrón almacenado circula y cada posición del patrón es un estado distinto.

Hay dos formas clásicas de cerrar el lazo:

Ambos son síncronos (un único reloj) y sencillos: no tienen lógica de acarreo ni estados falsos en la secuencia. Su punto débil es que usan muchos flip-flops para pocos estados y que, al encender, pueden arrancar en una secuencia equivocada que nunca se corrige sola. Este tema analiza ambas cosas.

02 · Anillo

Contador en anillo

Un contador en anillo de n bits es un registro de desplazamiento con la última salida unida a la primera entrada. Si arranca con un único 1 (por ejemplo 1000 en 4 bits), ese 1 recorre el registro posición por posición:

Cada salida está en alto exactamente uno de cada n pulsos (ciclo de trabajo 1/n) y a una frecuencia f / n. Las salidas ya son los pasos de la secuencia, sin ningún decodificador: el flip-flop número k es el paso k. Por eso este circuito es el favorito para generar señales de «turno»: habilitar un periférico por vez, barrer las filas de un teclado o de una matriz de LED.

Lo que se paga es la cantidad de flip-flops: n estados necesitan n flip-flops (un contador binario necesita log₂ n). Para secuencias cortas es un precio razonable; para 100 pasos, no.

03 · Autoarranque

El problema del arranque

Un anillo de 4 bits tiene 16 estados posibles, pero solo 4 son válidos (un único 1). Al encender, los flip-flops arrancan en un valor indefinido; si el estado inicial no es uno de los 4 buenos, el circuito entra en una secuencia equivocada. Como la realimentación directa solo mueve los bits, nunca los corrige:

Hay dos soluciones habituales:

• Inicialización explícita: un reset de encendido que cargue 1000 (por ejemplo, con el preset del primer flip-flop y el clear de los demás, tema 10). Es lo más simple y lo que se hace casi siempre.
• Realimentación autocorrectora: en vez de D₀ = Q_n−1 se usa D₀ = NOR(Q₀, …, Q_n−2): se inyecta un 1 solo cuando no hay ninguno en las primeras n − 1 posiciones. En la secuencia buena esta función da lo mismo que la realimentación directa; fuera de ella, ordena el circuito.

Con la realimentación NOR, de cualquiera de los 16 estados se llega a la secuencia buena en a lo sumo 3 pulsos (n − 1 en general). Por ejemplo, 1100 pasa por 0110 y 0011 hasta caer en 0001, y 0000 se arregla en un pulso.

04 · Johnson

Contador Johnson

Si la realimentación se invierte (D₀ = ~Q_n−1), el registro se «tuerce»: los unos entran de a uno hasta llenar todo el registro y después entran ceros hasta vaciarlo. La secuencia pasa por 2n estados distintos con solo n flip-flops:

Propiedades que hacen interesante al Johnson:

• Un solo bit cambia por paso. Entre dos estados consecutivos difiere exactamente un flip-flop, como en un código Gray. Eso evita los glitches al decodificar.
• Cada salida es una onda cuadrada de 50 %. Cada Q_k está n pulsos en alto y n en bajo: frecuencia f / (2n), con ciclo de trabajo del 50 %, y cada salida está desfasada de la siguiente en un pulso de reloj (360° / 2n). Con 4 bits, 45°.
• Duplica los estados: con n flip-flops, 2n estados, la mitad de flip-flops que un anillo equivalente.

Se pueden obtener otras fases más fáciles de usar combinando salidas: con un Johnson de 2 bits (4 estados), Q0 y Q1 son dos ondas cuadradas desfasadas 90°, una señal en cuadratura, la que entregan los codificadores rotativos y la que se necesita para generar fases.

05 · Decodificar

Decodificación sin glitches

Para obtener una salida distinta por estado, cada estado del Johnson se identifica mirando solo dos bits adyacentes. Por ejemplo, el estado 1100 es el único con Q1 = 1 y Q2 = 0; el 0111, el único con Q0 = 0 y Q1 = 1. Una compuerta AND de dos entradas por estado alcanza:

Como entre dos estados consecutivos solo cambia un flip-flop, nunca hay una carrera entre dos bits y las salidas de las AND no tienen glitches. Esa es la ventaja frente al contador binario con decodificador, donde los bits cambian casi a la vez y pueden producir pulsos falsos al pasar de un estado a otro (tema 17). Además, los decodificadores son pequeños: 2 entradas por salida, sin importar n.

Ciclos no válidos en el Johnson

También el Johnson tiene estados fuera de la secuencia: en 4 bits, los otros 8 estados (0010, 0100, 0101, 0110, 1001, 1010, 1011, 1101) forman un segundo ciclo de longitud 8 que nunca vuelve solo a la secuencia buena. Un arranque en uno de ellos deja las salidas decodificadas con patrones erróneos (varias activas a la vez o ninguna).

La corrección es similar a la del anillo, con una realimentación modificada. Para el Johnson de 4 bits, D₀ = ~Q₃ · (Q₀ + ~Q₂) da lo mismo que ~Q₃ en los 8 estados buenos y, desde cualquiera de los 16, llega a la secuencia buena en a lo sumo 5 pulsos. Para tamaños mayores la lógica de corrección es más elaborada, y lo habitual es resolverlo con un reset de encendido que cargue ceros.

06 · Comparación y componentes

Comparación y chips: 4017 y 4022

74HC4017 y 74HC4022

Los fabricantes ofrecen el contador Johnson con su decodificador ya integrado. El 74HC4017 es un Johnson de 5 etapas con 10 salidas decodificadas (Q0 a Q9, una activa por vez) y el 74HC4022, uno de 4 etapas con 8 salidas (Q0 a Q7):

El 4017 es el integrado clásico del chaser de LED: con un reloj en CLK, los diez LED se encienden de a uno. Para acortar la secuencia a N pasos basta con conectar la salida Q_N al MR: al aparecer, el chip se reinicia y vuelve a Q0. La salida CO, con 50 % de ciclo de trabajo, permite encadenar chips o dividir por diez.

07 · Aplicaciones

Aplicaciones: luces y motores

Secuenciador de luces

Un anillo de n bits con un LED por salida es el «auto fantástico» más simple: un LED se desplaza de posición en cada flanco. Con el Johnson se obtienen efectos de «barrido» que se llenan y se vacían (1000, 1100, 1110, 1111, 0111…). El tiempo por paso es el período del reloj; el recorrido completo, n / f en el anillo y 2n / f en el Johnson.

Motor paso a paso unipolar

Un motor paso a paso de cuatro bobinas (A, B, C, D) avanza un paso por cada patrón de corriente. El patrón es exactamente la secuencia de un registro circulante:

El medio paso es una aplicación elegante del Johnson: cada bobina es la AND de dos bits adyacentes (A = ~Q1·~Q2, B = Q0·~Q3, C = Q1·Q2, D = Q3·~Q0) y el patrón completo de ocho estados sale sin glitches. Las salidas del chip no mueven las bobinas directamente: hace falta un driver (un arreglo de transistores Darlington como el ULN2003) por la corriente y por las tensiones de arranque de las bobinas.

Fases y temporización

Un anillo de n bits alimentado con un reloj de frecuencia f entrega n señales de turno, cada una de duración 1/f, que se repiten con período n/f: una base de tiempos para repartir el ciclo en fases (por ejemplo, las fases de un semáforo o el barrido de un teclado matricial). Y como cada salida Q de un Johnson es una onda cuadrada de 50 %, el Johnson sirve para dividir por 2n con ciclo de trabajo simétrico.

08 · Anillo y Johnson en código

Ciclos, decodificación, frecuencias y motor

Los bloques enumeran los ciclos de los dos contadores, comprueban cómo cambia un solo bit por paso en el Johnson, calculan frecuencias y fases, y generan los patrones de un motor paso a paso con compuertas de dos entradas.

Paso 1: los ciclos del anillo y su autocorrección

from itertools import product


def siguiente(s, d0):
    return (d0(s),) + s[:-1]                  # s = (Q0, Q1, Q2, Q3); D0 viene de la realimentación


def ciclos(n, d0):
    vistos, resultado = set(), []
    for s in product((0, 1), repeat=n):
        if s in vistos:
            continue
        c, x = [s], siguiente(s, d0)
        while x not in c:
            c.append(x)
            x = siguiente(x, d0)
        if x == s:                                 # solo los estados que están DENTRO de un ciclo
            resultado.append(["".join(map(str, v)) for v in c])
            vistos.update(c)
    return resultado


anillo = lambda s: s[-1]                           # D0 = Q3
print("Contador en anillo de 4 bits: ciclos posibles de sus 16 estados")
for c in ciclos(4, anillo):
    marca = "  <- la secuencia buena" if "1000" in c else ""
    print(f"  longitud {len(c)}: {' '.join(c)}{marca}")

arranque = lambda s: int(not any(s[:-1]))          # D0 = NOR(Q0, Q1, Q2): inyecta un 1 cuando no hay ninguno
valido = {(1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1)}
print()
print("Con la realimentación D0 = NOR(Q0, Q1, Q2), pulsos hasta llegar a la secuencia buena:")
peor = 0
for s in product((0, 1), repeat=4):
    x, k = s, 0
    while x not in valido:
        x, k = siguiente(x, arranque), k + 1
    peor = max(peor, k)
    if k >= 2:
        print(f"  {''.join(map(str, s))}: {k} pulsos")
print(f"peor caso: {peor} pulsos")

Con realimentación directa, los 16 estados se reparten en seis ciclos: el bueno (longitud 4) y cinco que nunca salen solos, entre ellos 0000 y 1111 que ni siquiera se mueven. Con D0 = NOR(Q0, Q1, Q2), todos llegan a la secuencia buena en a lo sumo 3 pulsos: 0110, 0111, 1010 y 1011 en 2, y 1100, 1101, 1110 y 1111 en 3. Probá cambiar n a 5 y adaptar el NOR.

Paso 2: el Johnson, un bit por paso y su decodificación

from itertools import product


def siguiente(s, d0):
    return (d0(s),) + s[:-1]


johnson = lambda s: 1 - s[-1]                      # D0 = ~Q3
s = (0, 0, 0, 0)
estados = []
for _ in range(8):
    estados.append(s)
    s = siguiente(s, johnson)

print("paso  Q0Q1Q2Q3  cambios  salida decodificada (2 entradas)")
for k, e in enumerate(estados):
    q0, q1, q2, q3 = e
    prox = estados[(k + 1) % 8]
    cambios = sum(a != b for a, b in zip(e, prox))
    if k == 0:
        dec = "~Q0·~Q3"
    elif k == 4:
        dec = " Q0·Q3"
    elif k < 4:
        dec = f" Q{k - 1}·~Q{k}"
    else:
        dec = f"~Q{k - 5}· Q{k - 4}"
    print(f"{k:3d}   {''.join(map(str, e))}      {cambios}      {dec}")

print()
fix = lambda s: (1 - s[3]) & (s[0] | (1 - s[2]))   # D0 = ~Q3 · (Q0 + ~Q2)
valido = set(estados)
print("estados no válidos del Johnson de 4 bits (forman un ciclo de 8 que nunca vuelve solo):")
print(" ", " ".join("".join(map(str, e)) for e in product((0, 1), repeat=4) if e not in valido))
peor = 0
for e in product((0, 1), repeat=4):
    x, k = e, 0
    while x not in valido:
        x, k = siguiente(x, fix), k + 1
    peor = max(peor, k)
print(f"con D0 = ~Q3 · (Q0 + ~Q2) todos llegan a la secuencia buena en a lo sumo {peor} pulsos")

En cada paso cambia exactamente un bit, y cada estado se reconoce con dos entradas: 0000 con ~Q0·~Q3, 1000 con Q0·~Q1, y así hasta 0001 con ~Q2·Q3. Los otros ocho estados (0010, 0100, 0101, 0110, 1001, 1010, 1011, 1101) forman el ciclo no válido. Con D0 = ~Q3 · (Q0 + ~Q2) todos terminan en la secuencia buena en como máximo 5 pulsos.

Paso 3: frecuencias, fases y cantidad de flip-flops

f_reloj = 1000.0                          # Hz
for n in (4, 5, 8):
    f_anillo = f_reloj / n
    f_johnson = f_reloj / (2 * n)
    print(f"n = {n}: anillo -> cada salida a {f_anillo:6.1f} Hz, en alto 1/{n} del período ({100 / n:.1f} %); {n} estados")
    print(f"       Johnson -> cada salida a {f_johnson:6.1f} Hz con 50 % de ciclo de trabajo; {2 * n} estados con {n} flip-flops")
    print(f"       desfase entre salidas contiguas del Johnson: {360 / (2 * n):.1f} grados")

print()
print("flip-flops necesarios para N estados decodificados (sin decodificador externo):")
for N in (4, 8, 10, 16):
    print(f"  N = {N:2d}: anillo {N:2d} FF | Johnson {(N + 1) // 2:2d} FF | binario {max(1, (N - 1).bit_length())} FF + decodificador de {N} salidas")

Con un reloj de 1 kHz y 4 bits, el anillo entrega 250 Hz por salida con 25 % de ciclo de trabajo; el Johnson, 125 Hz con 50 % y fases separadas 45°. Con 8 bits el Johnson llega a 16 estados con 8 flip-flops (62,5 Hz y 22,5° entre salidas). Para 10 estados hacen falta 10 flip-flops en un anillo, 5 en un Johnson y 4 más un decodificador en un binario.

Paso 4: patrones de un motor paso a paso

estados = ["0000", "1000", "1100", "1110", "1111", "0111", "0011", "0001"]     # Johnson de 4 bits (Q0 Q1 Q2 Q3)

# cada bobina es una AND de 2 entradas (sin glitches)
bobinas = {
    "A": lambda q: (1 - q[1]) & (1 - q[2]),
    "B": lambda q: q[0] & (1 - q[3]),
    "C": lambda q: q[1] & q[2],
    "D": lambda q: q[3] & (1 - q[0]),
}
print("medio paso con un Johnson de 4 bits y cuatro AND de 2 entradas:")
print("paso  Q0Q1Q2Q3   A B C D")
for k, s in enumerate(estados):
    q = [int(c) for c in s]
    fila = [str(f(q)) for f in bobinas.values()]
    print(f"{k:3d}   {s}      {' '.join(fila)}")

paso_completo = ["1100", "0110", "0011", "1001"]
print()
print("paso completo con dos bobinas siempre activas (anillo de 4 con dos unos):", *paso_completo)
f_reloj = 400
print(f"con un reloj de {f_reloj} Hz el motor da {f_reloj} medios pasos por segundo ({f_reloj / 8:.0f} vueltas del patrón por segundo)")

La tabla recorre A, AB, B, BC, C, CD, D, DA: en los pasos pares hay una bobina y en los impares dos, que es el medio paso. Cada bobina sale de una AND de dos entradas del Johnson, y entre dos pasos consecutivos solo cambia una bobina. Con un reloj de 400 Hz el motor recibe 400 medios pasos por segundo (50 vueltas del patrón de ocho estados por segundo).

Los cuatro bloques muestran la misma idea: la secuencia, la decodificación y la tolerancia al arranque se estudian mirando todos los estados posibles, no solo los de la secuencia buena.

09 · Exploración interactiva

El laboratorio: anillo y Johnson

El simulador reproduce un registro de 3 a 8 flip-flops realimentado como anillo o como Johnson. Podés cargar cualquier estado inicial (incluso uno no válido), dar pulsos y ver la longitud del ciclo en el que quedó el circuito, si es válido y qué salida decodificada está activa. La casilla «autocorrección» cambia la realimentación por la que recupera el circuito (NOR en el anillo; ~Q·(Q0 + ~Q) en el Johnson de hasta 5 bits).

Recorrido guiado

1. Con el anillo de 4 bits en 1000, dale 4 pulsos: el 1 recorre Q1, Q2, Q3 y vuelve a Q0. La salida decodificada activa es S0, S1, S2 y S3. Es un contador con una sola salida activa por paso.
2. Escribí 1100 y presioná «Cargar estado»: es un estado no válido (dos unos). Dale 10 pulsos: sigue circulando con dos unos y nunca llega a la secuencia buena (ciclo de longitud 4).
3. Cargá 0000 y luego 1111: el ciclo es de longitud 1; con los pulsos no pasa nada. Es el bloqueo total.
4. Marcá «Autocorrección» y repetí el 1100: se recupera en 3 pulsos. «Pulsos hasta recuperarse» lo registra. Probá también 1111 (3 pulsos) y 0000 (1 pulso).
5. Pasá a Johnson de 4 bits con «Estado inicial estándar» (0000): la secuencia tiene 8 estados y cada pulso cambia un solo bit. Mirá cómo avanza la salida S0 a S7.
6. Cargá 0100 (estado no válido en el Johnson): el ciclo es de longitud 8 y las salidas decodificadas no se activan. Con «Autocorrección» llega a 0011 en 4 pulsos.
7. Subí a 5 flip-flops en Johnson: son 10 estados, el 4017 en miniatura. Con 6 o más, la autocorrección no está disponible: el laboratorio lo avisa y se usa la realimentación simple, como en un circuito real, donde se agregaría un reset.
8. Presioná «Estado al azar» varias veces con la autocorrección desmarcada: es lo que ocurre al encender el circuito. Contá en cuántas ocasiones arranca en un estado válido.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Predecí antes de simular

1. Posición del 1

Un anillo de 8 bits arranca con el 1 en Q0. ¿En qué salida está el 1 después de 21 pulsos?

2. Johnson de 5 bits

Un Johnson de 5 bits arranca en 00000 (Q0 Q1 Q2 Q3 Q4). ¿Cuántos estados tiene y qué valor tiene tras 7 pulsos?

3. Frecuencias

Se alimenta con 10 kHz un anillo de 5 bits y un Johnson de 5 bits. ¿Qué frecuencia y ciclo de trabajo tienen sus salidas Q?

4. Cuántos flip-flops

Se necesitan 12 salidas que se activen una por vez. ¿Cuántos flip-flops usa cada alternativa?

5. Estado de encendido

Un anillo de 4 bits con D0 = NOR(Q0, Q1, Q2) arranca en 0101. ¿En cuántos pulsos llega a la secuencia buena? ¿Y si arranca en 1010?

6. Diagnóstico

Un secuenciador con un Johnson de 4 bits armado con flip-flops sueltos funciona bien algunas veces al encender, y otras veces las salidas decodificadas se activan en patrones raros o ninguna. ¿Qué pasa y cómo se arregla?

12 · Síntesis

Ideas para recordar

¿Listo para el tema 22?

Antes de avanzar, explicá de memoria la diferencia entre anillo y Johnson, por qué un Johnson no produce glitches al decodificarlo y qué hay que hacer para que estos contadores arranquen bien. Si podés justificar las tres respuestas, ya podés generalizar la idea de «estado que cambia con cada reloj» a cualquier secuencia.

En el próximo tema veremos las máquinas de estados finitos: cómo describir con diagramas y tablas un circuito cuyo próximo estado depende del actual y de las entradas, de modo que contadores, anillos y secuenciadores sean casos particulares de un mismo método.