Jak rozumieć zatrzask SR

Nie mogę owinąć głowy, jak działa SR Latch. Pozornie podłączasz linię wejściową z R, a drugą z S i powinieneś uzyskać wyniki w Q i Q '.

Jednak zarówno R, jak i S wymagają danych wejściowych z danych wyjściowych drugiej strony, a dane wyjściowe drugiej strony wymagają danych wejściowych z danych wyjściowych drugiej strony. Co jest pierwsze, kurczak czy jajko?

Jak po raz pierwszy podłączyć ten obwód?

Pytanie spostrzegawcze. W rzeczywistości, jeśli zbudujesz tę zatrzask w programie symulacyjnym, rzeczywiście pokaże, że nie jest w stanie przewidzieć, w jakim stanie się uruchomi:

Ale jeśli ustawisz jedno z wejść na wysokie (są to przyciski po lewej), sygnał będzie się rozchodził (pamiętaj, 1 LUB [cokolwiek] równa się 1), a obwód zatrzaśnie ten stan:

Są to bramki NOR, więc odwrócona moc wyjściowa spada, gdy jedno z wejść jest wysokie. Program, którego użyłem to Logisim. Jest mały i polecam na początek. Kompilatory logiczne (FPGA i wszystko inne) uwielbiają narzekać na niezainicjowane stany. To był świetny pierwszy przykład.

Teraz wiem, że w prawdziwym życiu obwód losowo sam się zapadnie w jeden lub drugi stan. Wiele innych to zauważyło. Ale czasami ważne jest, aby niezawodnie zaczynało się w tym czy innym stanie i na tym właśnie polegają wszystkie ostrzeżenia.

Flip-flop został zaimplementowany jako biostabilny multiwibrator; dlatego Q i Q 'są gwarantowane jako odwrotność względem siebie dla wszystkich danych wejściowych z wyjątkiem S = 1, R = 1, co nie jest dozwolone. Tabela wzbudzeń dla przerzutnika SR jest pomocna w zrozumieniu, co dzieje się, gdy sygnały są podawane na wejścia.

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

Wyjścia Q i Q 'szybko zmienią stany i zatrzymają się w stanie ustalonym po podaniu sygnałów do S i 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).

Jeśli zbadamy najprostszą implementację przerzutnika SR (patrz http://en.wikipedia.org/wiki/File:Transistor_Bistable_interactive_animated_EN.svg ), odkryjemy, że składa się on z dwóch dwubiegunowych tranzystorów połączeniowych (BJT) i czterech rezystory (zamień przełączniki SPST na uziemienie na przełączniki SPDT, które mogą przełączać ustawione i zerowane linie między potencjałem uziemienia a V +). BJT są skonfigurowane jako wspólne falowniki emiterów. Kolektor (wyjście) każdego tranzystora jest doprowadzany z powrotem do podstawy (wejścia) przeciwnego tranzystora. Wejście S jest połączone drutowo z wyjściem BJT, którego połączenie kolektora służy jako wyjście Q (połączenie R1 / R3). Wejście R jest połączone drutowo z wyjściem BJT, którego połączenie kolektora służy jako wyjście Q '(połączenie R2 / R4).

Kiedy obwód pierwszy się włącza, żaden tranzystor nie jest skierowany do przodu w obszar nasycenia przez ułamek sekundy, co oznacza, że ​​zarówno Q, jak i Q 'są na poziomie logicznym 1. Napięcie dostępne na każdym kolektorze jest doprowadzane do podstawy przeciwnego tranzystora, co powoduje, że staje się on tendencyjny do przodu w kierunku obszaru nasycenia. Tranzystor, który jako pierwszy zostanie skierowany do przodu, zacznie najpierw przewodzić prąd, co z kolei spowoduje spadek napięcia na oporniku kolektora, ustawiając jego moc wyjściową na poziomie logicznym 0. Ten spadek napięcia kolektora zapobiegnie staje się stronniczy; dlatego ustawienie początkowego stanu przerzutnika. Zasadniczo jest to warunek wyścigu sprzętowego, który prowadzi do nieprzewidywalnego wyniku.

Jak powiedziałeś, jest niezdefiniowany. W praktyce występują stany przejściowe lub dziwactwa, które powinny wprowadzić zatrzask w określony stan, ale nie ma gwarancji, w jakim stanie się on znajdzie. Jest to spowodowane niedopasowaniem dwóch bramek, które określą dany stan początkowy (w zasadzie obwód nie działa zachowuje się jak prawdziwa cyfrowa zapadka SR, ale jest złożonym obwodem analogowym, jak w prawdziwym życiu). Wstępna produkcja będzie bardziej lub mniej przypadkowy, albo Q=1 and ~Q=0albo Q=0 and ~Q=1.

Z wyjątkiem wyraźnej wzmianki w arkuszu danych, nie polegałbym na tym, że jeden stan jest wybierany nad drugim, ponieważ rzeczywisty stan inicjacji może zmieniać się między różnymi częściami partii, umieszczaniem na płycie, czynnikami środowiskowymi (temperatura / wilgotność / itp.) I starzeniem się (bynajmniej nie pełna lista czynników).

Najlepszym sposobem zdefiniowania stanu jest po uruchomieniu potwierdzenie zestawu lub zresetowanie, aby ustawić zatrzask SR w znanym stanie.

Na marginesie, ogólnie zatrzaski SR potwierdzające jednocześnie S i R będą również skutkować nieokreślonym zachowaniem, a ty ustawiasz wyjścia na podobnym voodoo (prawdziwa implementacja może wyłączyć oba wyjścia, losowo przełączać oba, włącz oba wyjścia itd.). Jak skomentował supercat, jeśli jeden pin jest niepotwierdzony przed drugim, zatrzask SR może wejść w znany stan, ponieważ tylko jeden pin jest zapewniony. Inne typy zatrzasków / przerzutników mogą definiować inne zachowanie, na przykład przerzutniki JK definiują przypisywanie obu pinów do przełączania wyjść (Q = ~ Qprev, ~ Q = Qprev).

Pamiętaj, że bramy się odwracają. Zapewnia to dodatnią pętlę sprzężenia zwrotnego. Zakładając, że zarówno S, jak i R są równe zero, a jedno wyjście jest jedno, to ono dostarczy sygnał zwrotny do drugiej bramki, aby zmusić drugie wyjście do zera. W ten sposób bramy znajdują się w jednym z dwóch stabilnych stanów.

Jak tylko ustawisz jeden z S lub R na jeden, spowoduje to wymuszenie na odpowiedniej bramce wyjścia zerowego, co z kolei zmusi drugą bramkę do wyjścia zerowego. Znów stabilny.

Na przykład stan początkowy: S = 0, R = 0, Q = 0, Q # = 1. Teraz ustawiasz S = 1. Spowoduje to zmianę wyjścia dolnej bramki (Q #) na 0. To 0 jest podawane do górnej bramka, zmuszając wyjście (Q) do 1. Ta wartość 1 powraca do dolnej bramki. Po ustawieniu S z powrotem na 0, dolna bramka nadal odbiera 1 z drugiej bramki. Spowoduje to utrzymanie wyjścia Q # na poziomie 0.

Jeśli Q ma już wartość 1, a S ustawiono na 1, oba wejścia do dolnej bramki mają wartość 1, więc nie ma zmian.

Myślę, że ważna kwestia, o którą pytasz, ma związek z faktem, że zatrzask włącza się w nieznanym stanie, więc w jaki sposób możemy doprowadzić go do znanego stanu. Musisz pamiętać, że jeśli każde wejście do bramki NOR ma wartość 1, wówczas wyjście musi wynosić 0, niezależnie od stanu drugiego wejścia. Tak więc zastosowanie kombinacji wejściowych SET lub RESET zawsze wymusi zatrzask w ustawionym lub zresetowanym stanie, niezależnie od poprzedniego stanu zatrzasku.