Como entender a trava SR

Não consigo entender como o SR Latch funciona. Aparentemente, você conecta uma linha de entrada de R e outra de S e deve obter resultados em Q e Q '.

No entanto, R e S requerem entrada da saída do outro, e a saída do outro requer entrada da saída do outro. O que vem primeiro a galinha ou o ovo ??

Quando você conecta este circuito pela primeira vez, como ele começa?

Uma pergunta perceptiva. De fato, se você criar esse trinco em um programa de simulação, ele realmente mostrará que não é possível prever em que estado ele começará:

Mas se você definir uma das entradas como alta (esses são botões à esquerda), o sinal se propagará (lembre-se, 1 OU [qualquer coisa] é igual a 1) e o circuito trancará esse estado:

Como são portas NOR, a saída invertida fica baixa quando uma das entradas é alta. O programa que usei é o Logisim. É pequeno, e eu recomendo para começar. Os compiladores lógicos (FPGA e tudo o mais) gostam de reclamar de estados não inicializados. Este foi um ótimo primeiro exemplo.

Agora, eu sei que na vida real, o circuito aleatoriamente trava em um ou outro estado por conta própria. Muitos outros apontaram isso. Mas, às vezes, é importante que ele comece de maneira confiável em um estado ou outro, e é sobre isso que se trata todos os avisos.

Um flip-flop é implementado como um multivibrador biestável; portanto, Q e Q 'são garantidos como inversos entre todas as entradas, exceto S = 1, R = 1, o que não é permitido. A tabela de excitação para o flip-flop SR é útil para entender o que ocorre quando os sinais são aplicados às entradas.

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

As saídas Q e Q 'mudarão rapidamente de estado e pararão em um estado estável após os sinais serem aplicados 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 examinarmos a implementação mais simples de um flip-flop SR (consulte http://en.wikipedia.org/wiki/File:Transistor_Bistable_interactive_animated_EN.svg ), descobrimos que ele é composto por dois transistores de junção bipolar (BJTs) e quatro resistores (substitua os comutadores SPST por terra com os interruptores SPDT que podem alternar as linhas de configuração e redefinição entre o potencial de terra e V +). Os BJTs são configurados como inversores de emissor comuns. O coletor (saída) de cada transistor é retornado à base (entrada) do transistor oposto. A entrada S é conectada com a saída do BJT cuja conexão do coletor serve como saída Q (a junção de R1 / R3). A entrada R é conectada por um fio com a saída do BJT cuja conexão de coletor serve como saída Q '(a junção de R2 / R4).

Quando o circuito é ligado pela primeira vez, nenhum transistor é polarizado para a frente na região de saturação por uma pequena fração de segundo, o que significa que Q e Q 'estão no nível lógico 1. A tensão disponível em cada coletor é alimentada à base do transistor oposto, que faz com que ele se incline para frente na região de saturação. O transistor que se torna polarizado para a frente primeiro começa a conduzir a corrente primeiro, o que, por sua vez, causa uma queda de tensão no resistor do coletor, configurando sua saída para o nível lógico 0. Essa queda na tensão do coletor impedirá o transistor oposto de tornando-se tendencioso; portanto, definindo o estado inicial do flip-flop. É basicamente uma condição de corrida de hardware que leva a um resultado imprevisível.

Como você disse, é indefinido. Na prática, existem transitórios ou peculiaridades que devem colocar a trava em um determinado estado, mas não há garantia em qual estado ele estará. Isso é causado por incompatibilidade nos dois portões que definirão um determinado estado inicial (basicamente o circuito não se comporta como uma verdadeira trava digital SR, mas é um circuito analógico complexo, como na vida real). A saída inicial será mais ou menos aleatória, seja Q=1 and ~Q=0ou Q=0 and ~Q=1.

Com exceção da menção explícita em uma folha de dados, eu não confiaria que um estado fosse escolhido sobre o outro, pois o estado inicial real pode mudar entre diferentes partes do lote, posicionamento em uma placa, fatores ambientais (temperatura / umidade / etc.) E envelhecimento (de modo algum uma lista completa de fatores).

A melhor maneira de definir um estado é após a inicialização, afirmar o conjunto ou redefinir para colocar a trava do SR em um estado conhecido.

Como observação lateral, em geral as travas SR que afirmam S e R ao mesmo tempo também resultam em um comportamento indefinido e você depende de um vodu semelhante para definir as saídas (uma implementação real pode desligar as duas saídas, alternar aleatoriamente as duas, ativar as duas saídas, etc.). Como supercat comentou se um pino não é declarado antes do outro, a trava SR pode entrar em um estado conhecido porque apenas um pino está sendo declarado. Outros tipos de travas / flip-flops podem definir um comportamento diferente, por exemplo, os flip-flops JK definem a afirmação de ambos os pinos para alternar as saídas (Q = ~ Qprev, ~ Q = Qprev).

Lembre-se de que os portões estão invertendo. Isso fornece um loop de feedback positivo. Supondo que S e R sejam zero e uma saída seja uma, essa será realimentada na outra porta para forçar a outra saída a zero. Dessa forma, os portões estão em um dos dois estados estáveis.

Assim que você definir um de S ou R como um, isso forçará a porta correspondente a gerar zero, o que, por sua vez, forçará a outra porta a gerar zero. Mais uma vez, estável.

Por exemplo, estado inicial: S = 0, R = 0, Q = 0, Q # = 1. Agora você define S = 1. Isso alterará a saída da porta inferior (Q #) para 0. Esse 0 é alimentado na parte superior portão, forçando a saída (Q) a 1. Este 1 retorna ao portão inferior. Quando você define S de volta para 0, o portão inferior ainda recebe o 1 do outro portão. Isso manterá a saída Q # em 0.

Se Q já for 1 e você definir S como 1, ambas as entradas para o portão inferior serão 1 e, portanto, não haverá alteração.

Eu acho que a parte importante sobre a qual você está perguntando tem a ver com o fato de que a trava é ligada em um estado desconhecido; então, como a colocamos em um estado conhecido? É necessário lembrar que, se uma entrada para uma porta NOR for 1, a saída deverá ser 0, independentemente do estado da outra entrada. Portanto, aplicar as combinações de entrada SET ou RESET sempre forçará a trava ao estado definido ou redefinido, independentemente do estado anterior da trava.