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):
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):
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.