Come capire il fermo SR

Non riesco a capire come funziona SR Latch. Apparentemente, si collega una linea di input da R, e un'altra da S, e si suppone di ottenere risultati in Q e Q ′.

Tuttavia, sia R che S richiedono input dall'output dell'altro e l'output dell'altro richiede input dall'altro output. Cosa viene prima il pollo o l'uovo ??

Quando si collega per la prima volta questo circuito, come si avvia?

Una domanda percettiva. In effetti, se costruisci questo fermo in un programma di simulazione, ti mostrerà davvero che non può prevedere in quale stato inizierà:

Ma se si imposta uno degli ingressi in alto (quelli sono pulsanti a sinistra), il segnale si propaga attraverso (ricorda, 1 O [qualsiasi] è uguale a 1) e il circuito bloccherà quello stato:

Queste sono porte NOR, quindi l'uscita invertita diventa bassa quando uno degli ingressi è alto. Il programma che ho usato è Logisim. È piccolo e lo consiglio per iniziare. I compilatori di logiche (FPGA e tutto il resto) adorano lamentarsi di stati non inizializzati. Questo è stato un ottimo primo esempio.

Ora, so che nella vita reale, il circuito si bloccherà casualmente nell'uno o nell'altro stato da solo. Molti altri lo hanno sottolineato. Ma a volte, è importante che inizi in modo affidabile in uno stato o in un altro, e questo è tutto ciò che riguarda gli avvisi.

Un flip-flop è implementato come un multivibratore bi-stabile; pertanto, Q e Q 'sono garantiti in modo inverso tra loro per tutti gli ingressi tranne S = 1, R = 1, che non è consentito. La tabella di eccitazione per il flip-flop SR è utile per capire cosa succede quando i segnali vengono applicati agli ingressi.

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

Le uscite Q e Q 'cambieranno rapidamente stati e si fermeranno in uno stato stabile dopo che i segnali sono stati applicati a S e 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).

Se esaminiamo l'implementazione più semplice di un flip-flop SR (vedi http://en.wikipedia.org/wiki/File:Transistor_Bistable_interactive_animated_EN.svg ), scopriamo che è composto da due transistor di giunzione bipolari (BJT) e quattro resistori (sostituire gli interruttori a levetta SPST a terra con interruttori SPDT che possono commutare il set e ripristinare le linee tra potenziale di terra e V +). I BJT sono configurati come inverter per emettitori comuni. Il collettore (uscita) di ciascun transistor viene reinserito nella base (ingresso) del transistor opposto. L'ingresso S è collegato a filo con l'uscita del BJT il cui collegamento collettore funge da uscita Q (la giunzione di R1 / R3). L'ingresso R è collegato a filo con l'uscita BJT il cui collegamento collettore funge da uscita Q '(la giunzione di R2 / R4).

Quando il circuito si accende per la prima volta, nessuno dei due transistor viene polarizzato in avanti nella regione di saturazione per una piccola frazione di secondo, il che significa che sia Q che Q 'sono al livello logico 1. La tensione disponibile su ciascun collettore viene alimentata alla base del transistor opposto, che causa la polarizzazione in avanti nella regione di saturazione. Il transistor che per primo diventa polarizzato in avanti inizierà a condurre prima la corrente, che a sua volta provocherà una caduta di tensione attraverso il suo resistore del collettore, impostando la sua uscita al livello logico 0. Questa caduta nella tensione del collettore impedirà al transistor opposto di diventare prevenuto; pertanto, impostando lo stato iniziale del flip-flop. È fondamentalmente una condizione di competizione hardware che porta a un risultato imprevedibile.

Come hai detto, non è definito. In pratica ci sono transitori o stranezze che dovrebbero mettere il latch in un certo stato, ma non vi è alcuna garanzia in quale stato si troverà. Ciò è causato da una mancata corrispondenza nelle due porte che definirà un dato stato iniziale (sostanzialmente il circuito non si comporta come un vero latch digitale SR ma è un circuito analogico complesso come nella vita reale). L'output iniziale sarà più o meno casuale, o Q=1 and ~Q=0oppure Q=0 and ~Q=1.

Salvo esplicita menzione da parte di una scheda tecnica, non farei affidamento sulla scelta di uno stato rispetto all'altro in quanto lo stato iniziale effettivo può variare tra le diverse parti del lotto, il posizionamento su una scheda, i fattori ambientali (temperatura / umidità / ecc.) E l'invecchiamento (in nessun caso un elenco completo di fattori).

Il modo migliore per definire uno stato è dopo l'avvio affermare il set o il reset per mettere il latch SR in uno stato noto.

Come nota a margine, in generale i chiavistelli SR che affermano S e R allo stesso tempo comporteranno anche un comportamento indefinito e ti affidi a un voodoo simile per impostare gli output (un'implementazione reale può spegnere entrambi gli output, alternare casualmente i due, attiva entrambe le uscite, ecc.). Come ha commentato il supercat se un pin non è stato dichiarato prima dell'altro, il latch SR può entrare in uno stato noto perché viene affermato solo un pin. Altri tipi di latch / flip flop possono definire un comportamento diverso, ad esempio i flip-flop JK definiscono l'asserzione di entrambi i pin per attivare / disattivare le uscite (Q = ~ Qprev, ~ Q = Qprev).

Tieni presente che le porte si stanno invertendo. Ciò fornisce un circuito di feedback positivo. Supponendo che sia S che R siano pari a zero e che un'uscita sia una, questa verrà reinserita nell'altra porta per forzare l'altra uscita a zero. In questo modo, le porte sono in uno dei due stati stabili.

Non appena si imposta uno di S o R su uno, questo forzerà il gate corrispondente all'uscita zero che, a sua volta, forzerà l'altro gate all'uscita zero. Ancora una volta, stabile.

Ad esempio, lo stato iniziale: S = 0, R = 0, Q = 0, Q # = 1. Ora si imposta S = 1. Ciò modificherà l'uscita del gate inferiore (Q #) su 0. Questo 0 si inserisce nella parte superiore gate, forzando quell'uscita (Q) a 1. Questo 1 ritorna al gate inferiore. Quando si imposta S su 0, il gate inferiore sta ancora ricevendo l'1 dall'altro gate. Ciò manterrà l'uscita Q # a 0.

Se Q è già 1 e si imposta S su 1, entrambi gli ingressi per il gate inferiore sono 1 e quindi non vi sono cambiamenti.

Penso che la parte importante di cui stai chiedendo abbia a che fare con il fatto che il dispositivo di chiusura si accende in uno stato sconosciuto, quindi come possiamo mai portarlo in uno stato noto. È necessario ricordare che se uno degli ingressi di una porta NOR è un 1, l'uscita deve essere uno 0, indipendentemente dallo stato dell'altro ingresso. Pertanto, l'applicazione delle combinazioni di input SET o RESET forzerà sempre il latch nello stato impostato o ripristinato, indipendentemente dallo stato precedente del latch.