Bagaimana memahami SR Latch

Saya tidak bisa membungkus kepala saya di sekitar bagaimana SR Latch bekerja. Tampaknya, Anda mencolokkan saluran input dari R, dan yang lain dari S, dan Anda seharusnya mendapatkan hasil dalam Q dan Q ′.

Namun, baik R dan S membutuhkan input dari output yang lain, dan output yang lain membutuhkan input dari output yang lain. Apa yang lebih dulu ayam atau telur ??

Saat Anda pertama kali memasang sirkuit ini, bagaimana cara memulainya?

Sebuah pertanyaan perseptif. Faktanya, jika Anda membuat kait ini dalam sebuah program simulasi, ia akan menunjukkan kepada Anda bahwa ia tidak dapat memprediksi keadaan awal dari itu:

Tetapi jika Anda menetapkan salah satu input tinggi (itu adalah tombol tekan di sebelah kiri), sinyal akan merambat melalui (ingat, 1 ATAU [apa pun] sama dengan 1) dan sirkuit akan mengunci status itu:

Ini adalah gerbang NOR, sehingga output terbalik menjadi rendah ketika salah satu input tinggi. Program yang saya gunakan adalah Logisim. Ini kecil, dan saya merekomendasikannya untuk memulai. Compiler logika (FPGA dan yang lainnya) suka mengeluh tentang status yang tidak diinisialisasi. Ini adalah contoh pertama yang bagus.

Sekarang, saya tahu bahwa dalam kehidupan nyata, sirkuit akan secara acak terkunci ke satu atau negara lain sendiri. Banyak orang lain telah menunjukkan hal itu. Tetapi kadang-kadang, penting untuk memulai dengan andal di satu negara bagian atau lainnya, dan itulah peringatannya.

Flip-flop diimplementasikan sebagai multivibrator bi-stable; oleh karena itu, Q dan Q 'dijamin menjadi kebalikan satu sama lain untuk semua input kecuali S = 1, R = 1, yang tidak diperbolehkan. Tabel eksitasi untuk SR flip-flop sangat membantu dalam memahami apa yang terjadi ketika sinyal diterapkan pada input.

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

Output Q dan Q 'akan dengan cepat mengubah status dan berhenti pada kondisi stabil setelah sinyal diterapkan ke S dan 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).

Jika kita memeriksa implementasi SR flip-flop yang paling sederhana (lihat http://en.wikipedia.org/wiki/File:Transistor_Bistable_interactive_animated_EN.svg ), kami menemukan bahwa itu terdiri dari dua transistor persimpangan bi-polar (BJT) dan empat resistor (ganti sakelar sakelar SPST ke ground dengan sakelar SPDT yang dapat mengalihkan set dan setel ulang garis antara ground potensial dan V +). BJT dikonfigurasikan sebagai inverter emitor biasa. Kolektor (output) dari masing-masing transistor diumpankan kembali ke basis (input) dari transistor yang berlawanan. Input S adalah kawat-ORed dengan output BJT yang koneksi kolektornya berfungsi sebagai output Q (persimpangan R1 / R3). Input R adalah kawat-ORed dengan output BJT yang koneksi kolektornya berfungsi sebagai output Q '(persimpangan R2 / R4).

Ketika sirkuit pertama kali dinyalakan, tidak ada transistor yang bias maju ke daerah saturasi untuk sepersekian detik, yang berarti bahwa Q dan Q 'berada pada level logika 1. Tegangan yang tersedia di setiap kolektor diumpankan ke pangkalan dari transistor yang berlawanan, yang menyebabkannya menjadi maju bias ke wilayah saturasi. Transistor yang menjadi maju-bias pertama akan mulai melakukan arus terlebih dahulu, yang, pada gilirannya, akan menyebabkan penurunan tegangan terjadi pada resistor kolektornya, mengatur output ke level logika 0. Penurunan tegangan kolektor ini akan mencegah transistor berlawanan dari menjadi bias maju; Oleh karena itu, pengaturan keadaan awal flip-flop. Ini pada dasarnya adalah kondisi perlombaan perangkat keras yang mengarah pada hasil yang tidak terduga.

Seperti yang Anda katakan, itu tidak terdefinisi. Dalam prakteknya ada transien atau quirks yang harus menempatkan kait ke keadaan tertentu, tetapi tidak ada jaminan di negara mana ia akan berada. Hal ini disebabkan oleh ketidakcocokan dalam dua gerbang yang akan menentukan keadaan awal yang diberikan (pada dasarnya rangkaian tidak bisa berperilaku sebagai kait SR digital sejati tetapi merupakan rangkaian analog yang kompleks seperti di kehidupan nyata). Output awal akan lebih atau kurang acakQ=1 and ~Q=0 atau Q=0 and ~Q=1.

Kecuali disebutkan secara eksplisit oleh lembar data, saya tidak akan bergantung pada satu negara yang dipilih di atas yang lain karena keadaan init yang sebenarnya dapat berubah di antara berbagai bagian dalam batch, penempatan di papan, faktor lingkungan (suhu / kelembaban / dll.), Dan penuaan (Tidak berarti daftar lengkap faktor).

Cara terbaik untuk mendefinisikan suatu negara adalah setelah startup menyatakan set atau reset untuk menempatkan kait SR ke dalam kondisi yang diketahui.

Sebagai catatan tambahan, secara umum kait SR yang menyatakan S dan R pada saat yang sama juga akan menghasilkan perilaku yang tidak terdefinisi dan Anda mengandalkan voodoo yang sama untuk mengatur output (implementasi nyata dapat mematikan kedua output, secara acak beralih keduanya, aktifkan kedua output aktif, dll.). Sebagai supercat berkomentar jika satu pin tidak dipasang sebelum yang lain kait SR dapat memasuki kondisi yang diketahui karena hanya satu pin yang dinyatakan. Jenis kait / sandal jepit lain dapat menentukan perilaku yang berbeda, misalnya JK sandal jepit menentukan dengan menegaskan kedua pin untuk mengganti output (Q = ~ Qprev, ~ Q = Qprev).

Ingatlah bahwa gerbangnya terbalik. Ini memberikan loop umpan balik positif. Dengan asumsi bahwa S dan R adalah nol dan satu output adalah satu, yang ini akan mengumpan balik ke gerbang lain untuk memaksa output lainnya ke nol. Dengan cara ini, gerbang berada di salah satu dari dua kondisi stabil.

Segera setelah Anda menetapkan salah satu S atau R ke satu, ini akan memaksa gerbang yang sesuai untuk menghasilkan nol yang, pada gilirannya, akan memaksa gerbang lainnya untuk menghasilkan nol. Sekali lagi, stabil.

Misalnya, keadaan awal: S = 0, R = 0, Q = 0, Q # = 1. Sekarang Anda mengatur S = 1. Ini akan mengubah output gerbang yang lebih rendah (Q #) ke 0. 0 ini diumpankan ke atas gerbang, memaksa output (Q) ke 1. 1 ini mengumpan kembali ke gerbang bawah. Ketika Anda mengatur S kembali ke 0, gerbang bawah masih menerima 1 dari gerbang lainnya. Ini akan membuat output Q # pada 0.

Jika Q sudah 1 dan Anda mengatur S ke 1, kedua input ke gerbang bawah adalah 1 sehingga tidak ada perubahan.

Saya pikir bagian penting yang Anda tanyakan berkaitan dengan fakta bahwa kaitnya dalam keadaan tidak dikenal, jadi bagaimana kita bisa membuatnya menjadi keadaan yang diketahui. Anda harus ingat bahwa jika salah satu input ke gerbang NOR adalah 1 maka output harus berupa 0, terlepas dari keadaan input lainnya. Jadi, menerapkan kombinasi input SET atau RESET akan selalu memaksa kait ke keadaan set atau reset, terlepas dari keadaan kait sebelumnya.