Construa um registrador de deslocamento de 4 bit’s usando Flip-Flops D.

Passo 1

O enunciado pede para construir um registrador de deslocamento de 4 bits usando Flip-Flops tipo D. Ou seja:
  • O que é pedido: projetar um circuito sequencial que armazene 4 bits e que realize operação de deslocamento (shift) usando Flip-Flops D.
  • O que temos disponível: Flip-Flops D, um sinal de clock comum ao conjunto e entradas/saídas digitais (podemos adicionar sinais de controle como entrada serial, clear, load, etc., se quisermos).
  • O que preciso entregar explicitamente: as conexões entre as saídas Q dos Flip-Flops e as entradas D, a entrada serial (ou entradas de carga paralela, se optar por esse recurso), onde fica a saída serial e como ocorre o controle (por exemplo, load/shift).
    Nada mais foi dado no enunciado, então vou projetar a versão básica (funcional e de fácil compreensão), explicar todas as escolhas e também mostrar variações úteis para prova (SISO, SIPO, PISO, controle de carga e de direção).

Passo 2

Escolha do tipo de registrador e justificativa (sem cálculo, só metodologia).
  • Como não foi especificado qual variante, começo pelo mais didático e comum: um registrador de deslocamento serial-in, serial-out (SISO) que permite deslocar os bits a cada pulso de clock e tem uma entrada serial SI e uma saída serial SO.
  • Em seguida, mostro a adaptação para serial-in parallel-out (SIPO) (útil em muitas provas) e como adicionar um sinal LOAD para carga paralela e um CLR (clear) assíncrono.
    Essa escolha é natural: SISO é o bloco básico; P/parallelização basta usar as saídas Q já presentes.

Passo 3

Componentes e nomenclatura que vou usar (explico cada item como se você estivesse montando na prova):
  • Quatro Flip-Flops D, nomeados de FF3, FF2, FF1, FF0. Cada FF tem saída Q_i e entrada D_i para i=3,2,1,0.
  • Clock comum chamado CLK. Assumo Flip-Flops sensíveis à borda de subida (rising-edge), que é o caso mais comum. Isso significa que os valores nas entradas D_i são capturados e passam a valer nas Q_i apenas no instante da borda de subida do CLK.
  • Entrada serial SI (bit que entra no registrador durante o deslocamento).
  • Saída serial SO que vou escolher como a saída do bit deslocado para fora (no meu esquema SISO tipicamente SO = Q_0).
  • Opcional: entrada de carga paralela P_i para cada bit (se quisermos versão SIPO/PIPO), sinal de controle LOAD para selecionar entre carregar em paralelo ou deslocar, e sinal de reset/clear assíncrono CLR (ativa em nível 0 ou 1, explicarei como usar).

Passo 4

Esquema básico do registrador SISO (deslocamento para a direita) — descrição passo a passo e razão:
  • Definição do deslocamento para a direita: a cada borda de clock, o bit que estava em Q_3 vai para Q_2, o que estava em Q_2 vai para Q_1, o que estava em Q_1 vai para Q_0, e a nova entrada serial SI entra em Q_3. A saída serial SO pode ser tomada de Q_0 (o bit que sai pela direita).
  • Conexões físicas (as ligações que você desenharia no quadro):
    • Conectar D_3 à entrada serial SI.
    • Conectar D_2 à saída Q_3.
    • Conectar D_1 à saída Q_2.
    • Conectar D_0 à saída Q_1.
    • Tomar SO = Q_0.
    • Ligar todos os clocks CLK dos quatro Flip-Flops ao mesmo pulso de clock.
    • Opcional: ligar CLR assíncrono a um botão que zera todos os Q_i.
  • Em fórmulas simples (cada fórmula representa o valor que será aplicado em D_i logo antes da borda de captura):
D_3 = SI
D_2 = Q_3
D_1 = Q_2
D_0 = Q_1
  • Observação intuitiva: após uma borda de clock, as Q atualizam para os valores mostrados acima.

Passo 5

Por que isso funciona — explicando o princípio do Flip-Flop D de forma didática:
  • O Flip-Flop D armazena, na borda de captura do CLK, o valor presente em D. Ou seja, se o CLK tiver borda de subida, então imediatamente após essa borda Q passa a valer o valor que estava em D antes da borda (respeitando tempos de setup/hold).
  • Assim, se antes da borda eu coloquei D_2 = Q_3, no momento da borda Q_2 receberá o antigo Q_3, efetivando o deslocamento.
  • É importante (na prova) mencionar que todas as entradas D_i devem estar estáveis durante o intervalo de setup antes da borda e durante o hold logo após; normalmente as conexões diretas D_i\leftarrow Q_{i+1} satisfazem isso porque os Q mudam só na borda, e as D são saídas de outros FF que mudam simultaneamente — por isso todos os FF devem compartilhar o mesmo clock.

Passo 6

Exemplo numérico passo a passo (vai te ajudar a entender e fazer na prova):
  • Suponha estado inicial
Q_3 Q_2 Q_1 Q_0 = 1\;0\;1\;1
e tome SI = 1.
  • Antes do primeiro pulso de clock, aplicamos as conexões do Passo 4. No pulso de clock (borda de subida) as novas saídas serão:
Q_3 \leftarrow SI = 1
Q_2 \leftarrow Q_3_{\text{antigo}} = 1
Q_1 \leftarrow Q_2_{\text{antigo}} = 0
Q_0 \leftarrow Q_1_{\text{antigo}} = 1
  • Então após o primeiro clock o vetor fica
Q_3 Q_2 Q_1 Q_0 = 1\;1\;0\;1
  • Após o segundo clock (com o mesmo SI=1):
Q_3 Q_2 Q_1 Q_0 = 1\;1\;1\;0
  • Isso mostra claramente o deslocamento para a direita a cada pulso.

Passo 7

Como transformar o SISO em SIPO (serial-in, parallel-out) — versão prática para prova:
  • Na prática, nenhuma mudança em FF é necessária: as saídas Q_3,Q_2,Q_1,Q_0 já são pontos para leitura paralela. Basta usar essas saídas como saídas paralelas Y_3,Y_2,Y_1,Y_0.
  • Portanto a construção anterior já fornece SIPO: o circuito desloca serialmente e você pode ler em paralelo de suas saídas.

Passo 8

Como adicionar carga paralela (LOAD) para obter PIPO/PISO híbrido — circuito mais completo (útil em prova):
  • Objetivo: permitir, quando LOAD=1, carregar simultaneamente um vetor paralelo P_3P_2P_1P_0 nos Flip-Flops; quando LOAD=0 operar em modo shift normalmente.
  • Mecanismo: em cada entrada D_i coloque um multiplexador 2\!:\!1 que escolhe entre a linha de carga paralela P_i e a linha de deslocamento (conforme Passo 4). O seletor do MUX é LOAD.
  • Fórmulas para cada D_i (uso de notação booleana simples):
D_i = LOAD\cdot P_i + \overline{LOAD}\cdot S_i
onde S_i é a fonte do modo shift:
S_3 = SI,\quad S_2 = Q_3,\quad S_1 = Q_2,\quad S_0 = Q_1.
  • Interpretando: se LOAD=1 então D_i = P_i (carrega paralelo); se LOAD=0 então D_i = S_i (shift).

Passo 9

Como adicionar controle de direção (shift-left / shift-right) — versão avançada porém explicada:
  • Para suportar deslocamento em ambas as direções, usa-se um multiplexador adicional para escolher de onde vem cada D_i:
    • Se DIR=0 (shift-right): usar as conexões do Passo 4.
    • Se DIR=1 (shift-left): fazer o deslocamento na direção oposta, por exemplo: \text{shift-left: } D_3 = Q_2,\quad D_2 = Q_1,\quad D_1 = Q_0,\quad D_0 = SI_{R}onde SI_{R} é a entrada serial pela direita (bit que entra em Q_0 quando se faz shift-left).
  • Implementação: cada D_i usa um MUX 2\!:\!1 controlado por DIR para escolher entre as duas fontes de shift, e outro MUX para escolher entre load e shift (ou cascata de MUX).
  • Em fórmula compacta (assumindo já a seleção LOAD feita):
D_i = LOAD\cdot P_i + \overline{LOAD}\cdot\big(DIR\cdot S^{(L)}_i + \overline{DIR}\cdot S^{(R)}_i\big)
onde S^{(L)}_i e S^{(R)}_i são as fontes para shift-left e shift-right respectivamente.

Passo 10

Observações práticas que costumam cair em prova e que valem ponto:
  • Colocar um sinal CLR (ou RESET) assíncrono que zera todas as saídas é comum; indicar na planta que CLR vai às entradas de clear dos FF. Escrever: CLR=1 coloca Q_i=0 (ou o contrário dependendo do FF, detalhe que deve ser especificado).
  • Ligar todos os clocks juntos é essencial: registrador é sincronizado.
  • Cuidado com timing: em prova mencione setup time t_{su} e hold time t_{h} (bastante valem a explicação curta: entradas D devem ser estáveis pelo menos t_{su} antes da borda e por t_{h} após).
  • Se for implementar em TTL/CMOS real, evite feedback que altera D durante a borda; o esquema direto entre Q e D de registradores síncronos é correto porque as saídas mudam somente na borda.

Resposta

Construção básica (shift-right SISO de 4 bits):
D_3 = SI,\quad D_2 = Q_3,\quad D_1 = Q_2,\quad D_0 = Q_1,\quad SO = Q_0,
com todos os Flip-Flops D sincronizados ao mesmo CLK e opção de CLR assíncrono para zerar as saídas.
Versão com carga paralela (LOAD) — cada D_i tem um MUX 2\!:\!1:
D_i = LOAD\cdot P_i + \overline{LOAD}\cdot S_i,
com
S_3 = SI,\quad S_2 = Q_3,\quad S_1 = Q_2,\quad S_0 = Q_1.
Versão bidirecional (com DIR) — cada D_i escolhendo direção de shift e carga:
D_i = LOAD\cdot P_i + \overline{LOAD}\cdot\big(DIR\cdot S^{(L)}_i + \overline{DIR}\cdot S^{(R)}_i\big),
onde, por exemplo,
S^{(R)}_3 = SI_L,\; S^{(R)}_2=Q_3,\; S^{(R)}_1=Q_2,\; S^{(R)}_0=Q_1,
S^{(L)}_3 = Q_2,\; S^{(L)}_2=Q_1,\; S^{(L)}_1=Q_0,\; S^{(L)}_0=SI_R.

Exercícios relacionados