Preset, clear y arranque definido

01 · Punto de partida

Arrancar siempre igual

En el taller del tema 7 vimos que el latch arrancaba, a veces, con un LED encendido y otras veces con el otro. Con un biestable es un detalle curioso; con un contador de cuatro bits o una máquina de estados es un defecto: el semáforo podría encender con rojo y verde a la vez, el contador empezar en 11 y el candado en un estado en el que acaba de abrirse.

En software no ocurre: las variables se inicializan, o el lenguaje lo hace por nosotros (= 0, null). En el hardware, la inicialización también hay que diseñarla. Se hace en dos pasos: primero, un mecanismo que lleve a cada flip-flop a un valor conocido; segundo, algo que lo active siempre que el circuito arranca.

Retomamos lo que quedó pendiente en los temas 2, 4 y 7: el estado inicial, el arranque indefinido de un lazo y la prohibición de dejar entradas al aire.

02 · Las entradas

Preset y clear

Los flip-flops de uso general traen dos entradas que actúan sin esperar al reloj: preset (PRE), que lleva Q a 1, y clear (CLR, a veces llamada reset), que la lleva a 0. En la familia 74HC suelen ser activas en bajo (PRE̅ y CLR̅), y se indican con barra o burbuja. Son las mismas órdenes de Set y Reset del latch SR, aplicadas por encima del reloj.

Tres cosas para notar. Primero, PRE̅ y CLR̅ mandan sobre el reloj y sobre D: mientras estén activas, los flancos se ignoran. Segundo, ambas inactivas valen 1 (activas en bajo), lo que significa que si quedan al aire el circuito se comporta de forma imprevisible; deben atarse a +5 V cuando no se usan. Tercero, activar las dos a la vez es la combinación prohibida de siempre: como las entradas asíncronas actúan directamente sobre el latch de NAND interno (tema 5), las dos salidas valen 1, y soltarlas simultáneamente deja un estado impredecible.

03 · Dos formas de borrar

Reset asíncrono y reset síncrono

Hay otra manera de llevar un flip-flop a 0: sin usar CLR̅, y haciendo que D valga 0 cuando se aplica una señal de reset. Se la llama síncrona porque tiene efecto en el siguiente flanco del reloj. La diferencia entre las dos es fundamental:

El cronograma siguiente muestra los dos con la misma señal de reset: CLR̅ baja en t = 14 y se suelta en t = 22, con flancos de reloj en 4, 12, 20 y 28 y D = 1 siempre. El flip-flop asíncrono se borra apenas baja CLR̅; el síncrono espera el flanco de t = 20.

Observá además que el flanco de t = 20 llega con CLR̅ todavía activo y el asíncrono lo ignora, mientras que el síncrono lo usa para borrarse. Los dos terminan igual, capturando D = 1 en t = 28. Si el pulso de clear hubiera durado menos de un período y no hubiera contenido un flanco, el síncrono no se habría enterado (como los pulsos perdidos del tema 3).

04 · El disparador

El reset de encendido

Las entradas asíncronas resuelven el «cómo». Falta el «cuándo»: algo que active CLR̅ (o PRE̅) cada vez que el circuito recibe alimentación. El método clásico es un circuito RC que genera un pulso al subir la tensión:

1. Al encender, el condensador está descargado: el nodo vale 0 V y CLR̅, conectado a él, está activo.
2. El condensador se carga a través de la resistencia: v(t) = Vcc · (1 − e^−t/RC).
3. Cuando el nodo supera el umbral de entrada, CLR̅ pasa a inactivo y el circuito empieza a funcionar.

Dos inversores Schmitt en serie (por ejemplo, dos de los seis del 74HC14) limpian el flanco lento del condensador y entregan un nivel limpio. El pulsador a masa permite reiniciar a mano: descarga el condensador y vuelve a activar el reset. El diodo, en paralelo con la resistencia (con el cátodo hacia Vcc), descarga el condensador cuando se apaga la alimentación, para que un corte breve también genere un reset al volver.

La regla: el reset debe durar bastante más que lo que tarda la alimentación en estabilizarse, para que el circuito arranque cuando todos sus chips ya funcionan. Un reset más largo de lo necesario solo retrasa el arranque; uno más corto produce arranques erráticos. Cuando la fuente es lenta, tiene caídas o hay que garantizar el reset ante tensiones bajas, se usan circuitos integrados supervisores de tensión, que mantienen el reset hasta que Vcc supera un umbral preciso.

05 · Qué valor

Qué estado inicial elegir

Borrar todos los flip-flops (CLR̅) lleva al estado 0…0, que es el natural de un contador o un registro. Pero no siempre es lo correcto: la máquina puede necesitar empezar en otro estado, y se consigue combinando PRE̅ y CLR̅ bit a bit.

El ejemplo del anillo es instructivo: un contador en anillo (tema 21) necesita exactamente un 1 circulando. Si arranca con todos en 0, se queda en 0 para siempre; si arranca con dos, circulan dos. El reset de encendido es lo que lo hace funcionar.

Cuando el estado inicial es de seguridad, conviene que sea el que menos daño haga: salidas apagadas, motores detenidos, cerraduras trabadas (como el fail-closed del curso anterior). Y si se puede llegar a una combinación no usada por una perturbación, el diseño debe incluir una ruta de regreso a un estado válido.

06 · Tiempos

Los tiempos de las entradas asíncronas

«Asíncrono» no significa «sin tiempos». Las hojas de datos dan dos parámetros para PRE̅ y CLR̅:

El que causa los errores más difíciles es la recuperación. Si CLR̅ se suelta casi en el mismo instante del flanco de reloj, el flip-flop puede interpretar el flanco como válido o como ignorado, o quedar en un estado intermedio: es otra forma de metastabilidad, igual que una violación de setup (tema 8). Si el reset proviene de un pulsador o de un circuito RC, se suelta en un instante al azar respecto del reloj, así que alguna vez va a caer en esa ventana.

07 · Errores de diseño

Cuidados y errores comunes

El último caso merece una nota. Un truco antiguo para contar hasta 5 (módulo 6) es decodificar el valor 6 y usarlo para borrar el contador. Funciona, pero el 6 existe durante unos nanosegundos: lo que se decodifique de la cuenta (un display, una alarma) puede ver ese valor. Lo retomamos en el tema 19.

08 · Analogía con programación

Constructores, interrupciones y un reset suave

Un reset asíncrono es una interrupción no enmascarable: actúa al instante, sin esperar al bucle principal. Un reset síncrono es una bandera que el bucle consulta en cada iteración. El estado inicial es el constructor del objeto; el reset de encendido, el código que lo invoca antes de la primera línea útil.

Paso 1: un flip-flop D con preset y clear

class FlipFlopD74:
    """Flip-flop D con PRE y CLR asíncronos activos en bajo (como un 74HC74)."""

    def __init__(self, q=0):
        self.q, self.qn, self._clk = q, 1 - q, 0

    def evaluar(self, pre_n, clr_n, clk, d):
        if pre_n == 0 and clr_n == 0:
            self.q = self.qn = 1                 # combinación prohibida: las dos salidas en 1
        elif pre_n == 0:
            self.q, self.qn = 1, 0               # preset: no espera al reloj
        elif clr_n == 0:
            self.q, self.qn = 0, 1               # clear: no espera al reloj
        elif self._clk == 0 and clk == 1:        # flanco ascendente
            self.q, self.qn = d, 1 - d
        self._clk = clk
        return self.q, self.qn


ff = FlipFlopD74(q=1)                            # arranque con un valor desconocido
pasos = [("CLR activo, sin reloj",       1, 0, 0, 1),
         ("CLR suelto",                  1, 1, 0, 1),
         ("flanco ↑ con D = 1",          1, 1, 1, 1),
         ("reloj baja",                  1, 1, 0, 0),
         ("PRE activo, D = 0",           0, 1, 0, 0),
         ("flanco ↑ con PRE activo",     0, 1, 1, 0),
         ("PRE suelto, reloj baja",      1, 1, 0, 0),
         ("flanco ↑ con D = 0",          1, 1, 1, 0),
         ("PRE y CLR a la vez",          0, 0, 0, 0)]
print("evento                       PRE CLR CLK D | Q ~Q")
for nombre, pre_n, clr_n, clk, d in pasos:
    q, qn = ff.evaluar(pre_n, clr_n, clk, d)
    print(f"{nombre:28s}  {pre_n}   {clr_n}   {clk}  {d} | {q}  {qn}")

Sigue la tabla de la sección 2: CLR̅ activo lleva Q a 0 sin reloj; el flanco con D = 1 captura 1; con PRE̅ activo el flanco se ignora; y al final, PRE̅ y CLR̅ juntos dejan las dos salidas en 1. Probá a empezar con q=0 y repetir.

Paso 2: dimensionar el reset de encendido

import math

V_UMBRAL = 0.6                  # fracción de Vcc que el Schmitt toma como «alto» (orientativo)


def tiempo_de_reset(r_ohm, c_f, umbral=V_UMBRAL):
    """El condensador se carga desde 0: v(t) = Vcc·(1 − e^(−t/RC)). CLR queda en bajo hasta el umbral."""
    return -r_ohm * c_f * math.log(1 - umbral)


print("R         C        tau        CLR en bajo durante")
casos = [(10e3, 100e-9), (10e3, 1e-6), (100e3, 1e-6), (100e3, 10e-6), (1e6, 1e-6)]
for r, c in casos:
    t = tiempo_de_reset(r, c)
    unidad = (f"{t * 1000:.2f} ms" if t < 1 else f"{t:.2f} s")
    print(f"{r / 1000:6.0f} kΩ  {c * 1e6:6.2f} µF  {r * c * 1000:7.1f} ms  {unidad}")

print()
t_subida_vcc = 20e-3            # la alimentación tarda 20 ms en llegar a 5 V
for r, c in casos:
    t = tiempo_de_reset(r, c)
    veredicto = "sirve" if t > 2 * t_subida_vcc else "corto: el reset termina antes de que Vcc se asiente"
    print(f"{r / 1000:6.0f} kΩ · {c * 1e6:5.2f} µF: {veredicto}")

Con 100 kΩ y 1 µF, CLR̅ queda en bajo unos 92 ms, más del doble de los 20 ms que tarda la alimentación en asentarse. Con 10 kΩ y 0,1 µF, solo 0,9 ms: el reset termina antes de que Vcc llegue. Cambiá t_subida_vcc y mirá cuáles dejan de servir.

Paso 3: reset asíncrono frente a síncrono

N = 36
clk = [1 if t % 8 >= 4 else 0 for t in range(N)]          # flancos ↑ en t = 4, 12, 20, 28
clr_n = [0 if 14 <= t < 22 else 1 for t in range(N)]      # CLR activo (en bajo) entre t = 14 y 21
d = [1] * N

q_as, q_sin = [], []
a, s = 1, 1                                               # los dos arrancan en 1
clk_ant = 0
for t in range(N):
    sube = clk_ant == 0 and clk[t] == 1
    # reset asíncrono: actúa apenas CLR está activo
    if clr_n[t] == 0:
        a = 0
    elif sube:
        a = d[t]
    # reset síncrono: solo se mira CLR en el flanco
    if sube:
        s = 0 if clr_n[t - 1] == 0 else d[t]
    q_as.append(a)
    q_sin.append(s)
    clk_ant = clk[t]

print("t         ", *[t % 10 for t in range(N)])
print("CLK       ", *clk)
print("CLR (act. bajo)", *clr_n)
print("Q asíncrono", *q_as)
print("Q síncrono ", *q_sin)
primero = lambda q: next(t for t in range(14, N) if q[t] == 0)
print(f"\nel asíncrono baja en t = {primero(q_as)}, el síncrono en t = {primero(q_sin)} (primer flanco con CLR activo)")

Es el cronograma de la sección 3. El flip-flop asíncrono baja en t = 14, apenas se activa CLR̅; el síncrono recién en t = 20, el primer flanco con CLR̅ activo. Los dos vuelven a capturar D = 1 en t = 28. Probá un pulso de CLR̅ que no contenga ningún flanco: el síncrono ni se entera.

Paso 4: recuperación y el estado transitorio de un módulo 6

T_REC = 10.0       # ns: tiempo de recuperación antes del flanco (orientativo)


def liberar(t_libera, t_flanco):
    margen = t_flanco - t_libera
    if margen >= T_REC:
        return "ok: el flip-flop está listo para capturar en este flanco"
    if margen >= 0:
        return "violación de recuperación: el flanco puede ignorarse o dejar a Q indefinida"
    return "el flanco llegó con la entrada todavía activa: se ignora; captura en el siguiente"


print("CLR se suelta (ns antes del flanco) | resultado")
for antes in (50, 20, 10, 5, 0, -5):
    print(f"{antes:34d} | {liberar(100 - antes, 100)}")

print()
# Contador módulo 6 con clear asíncrono: se decodifica el valor 6 (110) y se borra
cuenta, visitados = 0, []
for flanco in range(14):
    cuenta = (cuenta + 1) & 7
    if cuenta == 6:                 # al llegar a 6, la decodificación activa CLR
        visitados.append("6*")      # el 6 existe unos nanosegundos
        cuenta = 0
    visitados.append(str(cuenta))
print("estados tras cada flanco:", *visitados)
print("(6* = estado transitorio: dura lo que tarda la compuerta en borrar, y puede producir un glitch)")

Soltar CLR̅ con 10 ns o más de anticipación es seguro; con menos hay una violación de recuperación. El contador que se borra al decodificar 6 pasa por el estado 6* en cada vuelta, un instante que un circuito rápido sí puede ver.

Una diferencia importante con el software: acá el «constructor» no corre solo. Si nadie activa el reset, el circuito arranca en el estado que le toque, y no hay ninguna excepción que avise.

09 · Exploración interactiva

Forzar un estado y arrancar

El laboratorio simula un flip-flop D de flanco ascendente con PRE̅ y CLR̅ asíncronos activos en bajo (como un 74HC74). Las casillas «activar» llevan el pin a 0. Con «Apagar y encender» podés probar el arranque: sin circuito de reset, Q toma un valor al azar; con reset de encendido, siempre queda en 0. El contador registra cuántos arranques salieron con Q = 1, que es lo que sucedería en un circuito real al repetir el experimento.

Recorrido guiado

1. Marcá «Dato D = 1» y generá un flanco: Q = 1. Es el funcionamiento normal.
2. Activá CLR̅: Q cae a 0 sin que haya flanco. La causa figura como «Clear». Generá flancos con CLR̅ activo: se ignoran, aunque D valga 1.
3. Soltá CLR̅: Q sigue en 0 y recién vuelve a 1 en el próximo flanco, que captura D = 1.
4. Activá PRE̅: Q = 1 aunque D valga 0. Los flancos vuelven a ignorarse.
5. Con PRE̅ activo, activá CLR̅: la combinación prohibida, Q y ~Q valen 1. Soltá PRE̅ antes que CLR̅: queda un clear, determinado. Probá el orden inverso.
6. Volvé a activar las dos y presioná «Soltar PRE̅ y CLR̅ a la vez»: el resultado es indeterminado. Repetilo varias veces y fijate que no siempre da lo mismo.
7. Presioná «Apagar y encender» diez veces sin el reset de encendido. El contador de arranques muestra que más o menos la mitad salió con Q = 1: así de impredecible es.
8. Marcá «Circuito de reset de encendido» y repetí: todos los arranques terminan en Q = 0, aunque internamente el flip-flop haya salido con un valor distinto.

10 · Método de trabajo

Cómo definir el arranque de un diseño

1. Escribí el estado inicial de la máquina (en la tabla de estados) y qué salidas produce.
2. Traducilo a PRE̅ y CLR̅ de cada flip-flop: los bits en 1 con preset, los bits en 0 con clear.
3. Elegí asíncrono o síncrono: asíncrono para el encendido y las emergencias; síncrono para los reinicios normales, si el reloj siempre está corriendo.
4. Diseñá el disparador: RC con Schmitt, un supervisor o un pulsador; verificá que dure más que la subida de Vcc.
5. Sincronizá la liberación con el reloj si el reset viene de afuera.
6. Atá las entradas sin usar a su nivel inactivo y comprobá que ninguna pueda tener glitches.
7. Revisá los estados sin usar y definí su regreso a un estado válido.
8. Probá el arranque muchas veces: apagar y encender repetidamente, con distintas rampas de tensión, y mirar que el estado sea siempre el mismo.

En la mesa, la prueba más reveladora es repetir el encendido diez o veinte veces mirando las salidas. Un circuito con arranque indefinido suele funcionar «casi siempre»: ese es el síntoma más molesto, porque no se reproduce a pedido.

11 · Comprensión

Confusiones frecuentes

12 · Práctica guiada

Predecí antes de comprobar

1. Seguir una secuencia

Un flip-flop D (flanco ascendente, PRE̅ y CLR̅ activos en bajo) parte de Q = 0. Se aplican en orden: (a) PRE̅ = 0 y se suelta; (b) flanco con D = 0; (c) CLR̅ = 0 y se suelta; (d) flanco con D = 1; (e) CLR̅ = 0 durante un flanco con D = 1. ¿Cuánto vale Q después de cada paso?

2. Dimensionar el reset

Con R = 100 kΩ, ¿qué valor comercial de C hace falta para un reset de al menos 200 ms (umbral de 0,6·Vcc)? ¿Qué pasa si la fuente tarda 150 ms en subir?

3. Un anillo bien arrancado

Un contador en anillo de 4 flip-flops (Q0 → D1, Q1 → D2, Q2 → D3, Q3 → D0) debe arrancar en 0001, con un único 1 en Q0. ¿Cómo se conectan PRE̅ y CLR̅ a la línea de reset?

4. Síncrono o asíncrono

Un reloj tiene período de 8 ticks. Un pulso de clear dura 3 ticks y cae entre dos flancos. ¿Se borra el flip-flop si el reset es asíncrono? ¿Y si es síncrono?

5. Recuperación

Un reloj de 20 MHz (T = 50 ns) y un flip-flop con t_rec = 10 ns. El reset viene de un pulsador y se suelta en un instante al azar. ¿Qué fracción de las liberaciones viola la recuperación? ¿Cómo se evita?

6. Diagnóstico

Un contador módulo 6, construido con un 74HC393 y una compuerta que detecta 110 y borra, a veces se cuelga o muestra un 6 en un display unos instantes. ¿Qué explica el síntoma y cómo se corrige?

13 · Síntesis

Ideas para recordar

¿Listo para el tema 11?

Antes de avanzar, explicá con tus palabras la diferencia entre un reset síncrono y uno asíncrono, calculá la duración de un reset RC y decidí cómo arrancaría un contador en anillo. Si podés justificar las tres respuestas, ya estás en condiciones de analizar los tiempos reales de un circuito secuencial.

En el próximo tema veremos tiempos reales y sincronización: setup, hold y retardos de propagación con más detalle, y la noción de metastabilidad con que nos encontramos varias veces en este curso.