Cómo entender el pestillo SR

No puedo entender cómo funciona el SR Latch. Aparentemente, conecta una línea de entrada desde R y otra desde S, y se supone que obtendrá resultados en Q y Q '.

Sin embargo, tanto R como S requieren la entrada de la salida del otro, y la salida del otro requiere la entrada de la salida del otro. ¿¿Qué viene primero, el huevo o la gallina??

Cuando conecta este circuito por primera vez, ¿cómo comienza?

Una pregunta perceptiva. De hecho, si construye este pestillo en un programa de simulación, de hecho le mostrará que no puede predecir en qué estado comenzará:

Pero si configura una de las entradas en alto (esos son botones a la izquierda), la señal se propagará (recuerde, 1 O [cualquier cosa] es igual a 1) y el circuito bloqueará ese estado:

Estas son puertas NOR, por lo que la salida invertida baja cuando cualquiera de las entradas es alta. El programa que utilicé es Logisim. Es pequeño, y lo recomiendo para comenzar. Los compiladores lógicos (FPGA y todo lo demás) adoran quejarse de estados no inicializados. Este fue un gran primer ejemplo.

Ahora, sé que en la vida real, el circuito se enganchará aleatoriamente en uno u otro estado por sí solo. Muchos otros lo han señalado. Pero a veces, es importante que comience de manera confiable en un estado u otro, y de eso se tratan todas las advertencias.

Un flip-flop se implementa como un multivibrador biestable; por lo tanto, Q y Q 'están garantizados como inversos entre sí para todas las entradas, excepto S = 1, R = 1, que no está permitido. La tabla de excitación para el flip-flop SR es útil para comprender qué ocurre cuando se aplican señales a las entradas.

S R  Q(t) Q(t+1)   
----------------
0 x   0     0       
1 0   0     1   
0 1   1     0   
x 0   1     1   

Las salidas Q y Q 'cambiarán rápidamente de estado y se detendrán en un estado estable después de que se hayan aplicado señales a S y R.

Example 1: Q(t) = 0, Q'(t) = 1, S = 0, R = 0. 

State 1: Q(t+1 state 1)  = NOT(R OR Q'(t)) = NOT(0 OR 1) = 0
         Q'(t+1 state 1) = NOT(S OR Q(t)) =  NOT(0 OR 0) = 1

State 2: Q(t+1 state 1)  = NOT(R OR Q'(t+1 state 1)) = NOT(0 OR 1) = 0
         Q'(t+1 state 2) = NOT(S OR Q(t+1 state 1))  =  NOT(0 OR 0) = 1     

Since the outputs did not change, we have reached a steady state; therefore, Q(t+1) = 0, Q'(t+1) = 1.


Example 2: Q(t) = 0, Q'(t) = 1, S = 0, R = 1

State 1: Q(t+1 state 1)  = NOT(R OR Q'(t)) = NOT(1 OR 1) = 0
         Q'(t+1 state 1) = NOT(S OR Q(t))  = NOT(0 OR 0) = 1


State 2: Q(t+1 state 2)  = NOT(R OR Q'(t+1 state 1)) = NOT(1 OR 1) = 0
         Q'(t+1 state 2) = NOT(S OR Q(t+1 state 1))  =  NOT(0 OR 0) = 1     


We have reached a steady state; therefore, Q(t+1) = 0, Q'(t+1) = 1.


Example 3: Q(t) = 0, Q'(t) = 1, S = 1, R = 0

State 1: Q(t+1 state 1)  = NOT(R OR Q'(t)) = NOT(0 OR 1) = 0
         Q'(t+1 state 1) = NOT(S OR Q(t)) =  NOT(1 OR 0) = 0

State 2: Q(t+1 state 2)  = NOT(R OR Q'(t+1 state 1)) = NOT(0 OR 0) = 1
         Q'(t+1 state 2) = NOT(S OR Q(t+1 state 1))  = NOT(1 OR 0) = 0     

State 3: Q(t+1 state 3)  = NOT(R OR Q'(t+1 state 2)) = NOT(0 OR 0) = 1
         Q'(t+1 state 3) = NOT(S OR Q(t+1 state 2))  = NOT(1 OR 1) = 0     

We have reached a steady state; therefore, Q(t+1) = 1, Q'(t+1) = 0.


Example 4: Q(t) = 1, Q'(t) = 0, S = 1, R = 0

State 1: Q(t+1 state 1)  = NOT(R OR Q'(t)) = NOT(0 OR 0) = 1
         Q'(t+1 state 1) = NOT(S OR Q(t)) =  NOT(1 OR 1) = 0

State 2: Q(t+1 state 2)  = NOT(R OR Q'(t+1 state 1)) = NOT(0 OR 0) = 1
         Q'(t+1 state 2) = NOT(S OR Q(t+1 state 1))  = NOT(1 OR 1) = 0     

We have reached a steady state; therefore, Q(t+1) = 1, Q'(t+1) = 0.


Example 5: Q(t) = 1, Q'(t) = 0, S = 0, R = 0

State 1: Q(t+1 state 1)  = NOT(R OR Q'(t)) = NOT(0 OR 0) = 1
         Q'(t+1 state 1) = NOT(S OR Q(t)) =  NOT(0 OR 1) = 0

State 2: Q(t+1 state 2)  = NOT(R OR Q'(t+1 state 1)) = NOT(0 OR 0) = 1
         Q'(t+1 state 2) = NOT(S OR Q(t+1 state 1))  = NOT(0 OR 1) = 0     

We have reached a steady; state therefore, Q(t+1) = 1, Q'(t+1) = 0.


With Q=0, Q'=0, S=0, and R=0, an SR flip-flop will oscillate until one of the inputs is set to 1.

    Example 6: Q(t) = 0, Q'(t) = 0, S = 0, R = 0

    State 1: Q(t+1 state 1)  = NOT(R OR Q'(t)) = NOT(0 OR 0) = 1
             Q'(t+1 state 1) = NOT(S OR Q(t)) =  NOT(0 OR 0) = 1

    State 2: Q(t+1 state 2)  = NOT(R OR Q'(t+1 state 1)) = NOT(0 OR 1) = 0
             Q'(t+1 state 2) = NOT(S OR Q(t+1 state 1))  = NOT(0 OR 1) = 0     

    State 3: Q(t+1 state 3)  = NOT(R OR Q'(t+1 state 2)) = NOT(0 OR 0) = 1
             Q'(t+1 state 3) = NOT(S OR Q(t+1 state 2)) =  NOT(0 OR 0) = 1

    State 4: Q(t+1 state 4)  = NOT(R OR Q'(t+1 state 3)) = NOT(0 OR 1) = 0
             Q'(t+1 state 4) = NOT(S OR Q(t+1 state 3))  = NOT(0 OR 1) = 0     
    ...


As one can see, a steady state is not possible until one of the inputs is set to 1 (which is usually handled by power-on reset circuitry).

Si examinamos la implementación más simple de un flip-flop SR (ver http://en.wikipedia.org/wiki/File:Transistor_Bistable_interactive_animated_EN.svg ), descubrimos que está compuesto por dos transistores de unión bipolares (BJT) y cuatro resistencias (reemplace los interruptores de palanca SPST a tierra con interruptores SPDT que pueden cambiar el conjunto y restablecer las líneas entre el potencial de tierra y V +). Los BJT están configurados como inversores emisores comunes. El colector (salida) de cada transistor se retroalimenta a la base (entrada) del transistor opuesto. La entrada S está cableada con la salida del BJT cuya conexión de colector sirve como salida Q (la unión de R1 / R3). La entrada R está cableada con la salida BJT cuya conexión de colector sirve como salida Q '(la unión de R2 / R4).

Cuando el circuito se enciende por primera vez, ninguno de los transistores se polariza en la región de saturación durante una pequeña fracción de segundo, lo que significa que tanto Q como Q 'están en el nivel lógico 1. El voltaje disponible en cada colector se alimenta a la base del transistor opuesto, lo que hace que se polarice hacia adelante en la región de saturación. El transistor que se polariza hacia adelante primero comenzará a conducir corriente primero, lo que, a su vez, provocará una caída de voltaje en su resistencia del colector, estableciendo su salida en el nivel lógico 0. Esta caída en el voltaje del colector evitará que el transistor opuesto volverse sesgado hacia adelante; por lo tanto, establecer el estado inicial del flip-flop. Básicamente es una condición de carrera de hardware que conduce a un resultado impredecible.

Como dijiste, no está definido. En la práctica, hay transitorios o caprichos que deberían poner el pestillo en un cierto estado, pero no hay garantía de en qué estado estará. Esto es causado por un desajuste en las dos puertas que definirán un estado inicial dado (básicamente el circuito no No se comporta como un verdadero enganche SR digital, pero es un circuito analógico complejo como lo es en la vida real). La salida inicial será más o menos aleatoria, ya sea Q=1 and ~Q=0oQ=0 and ~Q=1 .

Salvo que una hoja de datos mencione explícitamente, no confiaría en que se elija un estado sobre el otro, ya que el estado inicial real puede cambiar entre las diferentes partes del lote, la colocación en un tablero, los factores ambientales (temperatura / humedad / etc.) Y el envejecimiento (de ninguna manera una lista completa de factores).

La mejor manera de definir un estado es después del inicio, afirmar el conjunto o restablecer para poner el bloqueo SR en un estado conocido.

Como nota al margen, en general, los bloqueos SR que afirman S y R al mismo tiempo también darán lugar a un comportamiento indefinido y dependerá de un vudú similar para configurar las salidas (una implementación real puede apagar ambas salidas, alternar aleatoriamente las dos, alternar ambas salidas, etc.). Como supercat comentó si un pin no está insertado antes que el otro, el pestillo SR puede entrar en un estado conocido porque solo se está afirmando un pin. Otros tipos de pestillos / flip-flops pueden definir un comportamiento diferente, por ejemplo, los flip-flops JK definen la afirmación de ambos pines para alternar las salidas (Q = ~ Qprev, ~ Q = Qprev).

Tenga en cuenta que las puertas están invirtiendo. Esto proporciona un ciclo de retroalimentación positiva. Suponiendo que tanto S como R son cero y una salida es una, esta retroalimentará a la otra puerta para forzar la otra salida a cero. De esta manera, las puertas están en cualquiera de los dos estados estables.

Tan pronto como establezca uno de S o R en uno, esto forzará a la puerta correspondiente a salir a cero, lo que a su vez forzará a la otra puerta a salir a cero. De nuevo, estable.

Por ejemplo, estado inicial: S = 0, R = 0, Q = 0, Q # = 1. Ahora configura S = 1. Esto cambiará la salida de la puerta inferior (Q #) a 0. Este 0 alimenta a la superior puerta, forzando esa salida (Q) a 1. Este 1 retroalimenta a la puerta inferior. Cuando vuelve a establecer S en 0, la puerta inferior todavía recibe el 1 de la otra puerta. Esto mantendrá la salida Q # en 0.

Si Q ya es 1 y configura S en 1, ambas entradas a la puerta inferior son 1 y, por lo tanto, no hay cambio.

Creo que la parte importante que está preguntando tiene que ver con el hecho de que el pestillo se activa en un estado desconocido, entonces, ¿cómo podemos llevarlo a un estado conocido? Debe recordar que si cualquiera de las entradas a una puerta NOR es un 1, la salida debe ser un 0, independientemente del estado de la otra entrada. Por lo tanto, la aplicación de las combinaciones de entrada SET o RESET siempre forzará el pestillo al estado establecido o de reinicio, independientemente del estado anterior del pestillo.