Projeto de Lógica Digital

de projeto** — como os bits são representados, combinados, armazenados e sincronizados dentro de cada computador. Não requer conhecimento prévio em eletrônica: os primários são dois níveis de tensão e um punhado de portas lógicas. e um punhado de portas lógicas. níveis e um punhado de portas lógicas.

• A unidade 3.1 constrói os sistemas numéricos: binário, hexadecimal, complemento de dois.
• As unidades 3.2–3.3 combinam lógica: álgebra booleana, mapas de Karnaugh, combinacional blocos.
• Unidades 3.4–3.5 adicionam tempo: latches, flip-flops e máquinas de estado com clock.
• Unidade 3.6 registra os padrões: contadores, registros de deslocamento e memória.
• Unidade 3.7 descreve-os em HDL e verifica com testbenches.

Cada unidade abre com uma história, mostra uma imagem antes do conceito formal, define termos com precisão, trabalha dois exemplos crescentes cuja aritmética é verificada por máquina, nomeia erros clássicos e encerra com um resumo de três linhas. O hábito de verificação deste curso: toda resposta booleana é verificada por resumo. O hábito de verificação deste curso: cada resposta booleana é verificada por avaliação exaustiva — uma função com 3 entradas tem apenas 8 linhas, então verifique todas elas, seja manualmente em uma tabela-verdade ou por meio de um loop na sandbox.

Um termostato exibe 22.5 °C, mas o microcontrolador por trás dele armazena apenas bits. Como 22.5 se torna um padrão de bits que uma máquina pode somar, comparar e armazenar? A unidade 3.1 é essa tradução, em ambas as direções.

Computadores armazenam números em binário (base 2). A conversão é sistemática: divida por 2 para inteiros (coleta de restos), multiplique por 2 para frações. Hexadecimal (base 16) é a forma abreviada do binário — cada dígito hex corresponde exatamente a 4 bits: $0xB = 1011$.

Derivando complemento de dois. Queremos um código onde a subtração reutilize o somador: $a - b = a + (b\text{ negated})$ deve conter módulo $2^N$. O acréscimo o inverso de $b$ módulo $2^N$ é $2^N - b = (2^N - 1 - b) + 1$ — e $2^N - 1 - b$ é exatamente "todos os bits de $b$ invertidos" (cada bit com peso 1 alterna entre 0 e vice-versa). Assim, negar = inverter + 1, e a derivação é a prova de que a adição funciona. inalterado.

Complemento de dois representa inteiros sinalizados em N bits: inverta inverta todos os bits e adicione 1 para negar. Em 8 bits, $-5$ é $\overline{00000101}$ mais 1, que é $11111011$. O intervalo vai de $-2^{N-1}$ até $+2^{N-1}-1$ — isto é, de −128 a +127 em 8 bits. Estouro ocorre quando o resultado sai do intervalo: somar dois positivos e obter um negativo (ou vice-versa) é a detecção baseada no sinal; o carry para fora do MSB não é estouro; o carry saindo diferindo do carry entrando no MSB sim é. para o bit mais significativo é.

Exemplo resolvido 1 (conversão e verificação). Converta 156 para binário: $156 = 128 + 16 + 8 + 4 = 10011100$ ✓. O mesmo número em hexadecimal: agrupe os bits em quadras $128 + 16 + 8 + 4 = 156$ ✓. O mesmo número em hexadecimal: agrupe os bits em grupos de quatro da direita — $1001\ 1100 = 0x9C$ ✓. E a fração 0.625: multiplique por 2 → 1.25 (1), 0.25×2 → 0.5 (0), 0.5×2 → 1.0 (1): $0.625 = 0.101_2$ ✓ ($0.5 + 0.125$).

Exemplo resolvido 2 (números negativos e transbordo, escalonado). Codifique −100 em 8 bits: $100 = 01100100$; inverta $10011011$; adicione 1 → $10011100$. Verifique 156, então em sinalizado de $156 - 256 = -100$ bit não cabe — os bits calculam $100 + 50 = 150 > 127$, que decodifica para 8. A regra de sinal captura: positivo + $10010110$, que decodifica para $-106$. A regra do sinal captura isso: positivo + leitura positiva de um negativo ✓ (e o carry-into-MSB foi 1 enquanto o carry-out foi 0). A máquina não falhou; a largura falhou.

Erros comuns. Ler complemento de dois como sem sinal (156 e −100 compartilham bits — decide o interpretador). Esquecer o intervalo assimétrico: −128 existe, +128 não. Tratar carry-out como overflow — apenas a discrepância de carry conta.

Resumo: binário↦decimal por pesos e duplicação; hex agrupa em quatros; complemento de dois = inverter + 1, intervalo $-2^{N-1}\ldots 2^{N-1}-1$; overflow é detectado por discrepância de sinal, não por carry-out.

Uma luz de corredor deve ser acionável de ambas as extremidades: dois interruptores, uma lâmpada — o XOR que o eletricista liga é uma função booleana. Álgebra booleana manipula expressões com AND ($\cdot$), OR ($+$), NOT ($'$). As leis espelham a álgebra comum mais a absorção: $A + A\cdot B = A$ e $A\cdot (A+B) = A$. Teorema de De Morgan é a ferramenta principal:

— rompa a barra, alterne o sinal.

O mapa de Karnaugh organiza uma tabela-verdade de modo que células adjacentes difiram em uma variável (ordem Gray); grupos de 1, 2, 4, 8 células (potências de dois, retângulos) lidos como termos produtos.

Exemplo resolvido 1 (a função ímpar). A função de variável 3 $F = \sum m(1, 3, 5, 7)$ (linhas ímpares) mapeia para um par de colunas — toda célula onde $C = 1$ — então $F = C$ diretamente: todos os quatro minitermos compartilham apenas $C$. O verificação: avalie $C$ contra todas as linhas 8 originais; corresponde exatamente (verificado por máquina). Don't-cares (combinações de entrada impossíveis) podem junte-se a qualquer grupo — use-os para expandir grupos, nunca para criar novos.

Exemplo resolvido 2 (maioria de variável 4, verificada por máquina, escalonada). A função maioria $M(A,B,C,D)$ é 1 quando três ou mais entradas são 1: seus mintermos são $\sum m(7, 11, 13, 14, 15)$. Agrupamento no mapa de variável 4: quatro pares sobrepostos, cada um compartilhando $m_{15}$, geram $ABC + ABD + ACD + BCD$, que fatoram para $M = A\cdot B\cdot(C + D) + C\cdot D\cdot(A + B)$. Verificação da máquina: avalie tanto a definição (contagem $\geq 3$) quanto a expressão em todas as linhas 16 — elas concordam em todos os lugares ✓. Note a forma da resposta: o mapa fornece quatro produtos de entrada 3 em vez de uma soma de mintermos plana 5, e fatorá-los em dois produtos economiza portas adicionais.

Erros comuns. Agrupar diagonais (células devem ser retângulos na envoltória Gray, então bordas se tocam). Escrever termo de agrupamento a partir de variáveis que alteram dentro do agrupamento — apenas as variáveis constantes permanecem. Confiar em simplificação não verificada: a verificação das linhas 16 é gratuita.

Resumo: leis Booleanas e De Morgan transformam expressões; mapas K agrupam retângulos de potências de dois em ordem Gray; grupos mantêm apenas variáveis constantes; don't-cares ampliam mas nunca criam; verifique toda simplificação exaustivamente.

Uma máquina de venda dispensa uma de quatro bebidas mediante duas pressões de botão: esse seletor, o decodificador atrás do display, o somador dentro da lógica de troco — blocos combinacionais são a camada intermediária reutilizável entre portas e sistemas. Portas lógicas formam blocos padrão de lógica combinacional cujos comportamento é uma função pura das entradas atuais:

• Multiplexador (MUX): seletor de dados de $2^n$ para 1; os n bits de seleção escolhem uma entrada. $Y = \sum (D_i \cdot minterm_i(selects))$.
• Decodificador: n entradas para $2^n$ saídas, exatamente uma alta — gerador de mintermo.
• Adder: um somador parcial soma dois bits ($S = A \oplus B$, carry $C = A\cdot B$); um somador completo adiciona três (dois operandos mais carry-in): $S = A \oplus B \oplus C_{in}$, $C_{out} = A\cdot B + C_{in}\cdot (A \oplus B)$.

Exemplo resolvido 1 (o MUX e o somador, verificados). Um MUX de 4-para-1 com seleção $S_1S_0 = 10$ produz $D_2$ — o peso decimal do código de seleção nomeia o entrada de dados. Verificação do somador completo em $A=1, B=1, C_{in}=1$: $S = 1\oplus 1\oplus 1 = 1$, $C_{out} = 1 + 1\cdot 0 = 1$ — três uns entrando, binário 11 saindo (soma 1, carry 1): $3 = 2 + 1$ ✓.

Exemplo resolvido 2 (um somador em cascata de 2 bits, verificado por máquina, escalonado). Encadeie dois somadores completos: o primeiro soma os bits baixos, seu carry alimenta o segundo. Adicionando $11_2 + 01_2$ ($3 + 1$): bits baixos $1 + 1$ resultam em $S_0 = 0$, carry 1; bits altos bits $1 + 0 + 1$ resultam em $S_1 = 0$, carry 1 — saída $100_2 = 4$ ✓ (máquina máquina através de todos os quatro pares de entrada por estágio). O padrão escala exatamente: um somador de n-bits é n somadores completos e nada mais, e o carry propaga-se em cascata através dele — que também é seu limite de velocidade, corrigido posteriormente pelo lookahead de carry.

Riscos são falhas momentâneas na saída quando mudanças nas entradas levam tempos caminhos; eles importam porque um glitch pode ser captado como borda de clock. A solução é agrupamento redundante (mantendo a cobertura de perigo) — detecte-os por enumeração quando a especificação proíbe glitches.

Erros comuns. Ler um MUX de trás para frente (a seleção escolhe dados, não o valor da saída). Esquecer a direção da cadeia de carry em somadores ripple. Tratar uma hazard como erro de lógica — o valor final está correto; o transitório é o bug.

Resumo: MUX seleciona por código ponderado, decodificador gera mintermos, somador completo = cinco portas somando três bits; cadeias ripple escalam por repetição; hazards são transitórias e a cobertura redundante as remove.

Um campainha lembra que foi pressionada após o dedo sair — a memória mais simples é o feedback. Lógica sequencial possui estado — memória. Um latch é sensível ao nível: o latch SR (NOR cruzado) lembra qual entrada pulsou; o latch D segue D enquanto ENABLE está alto, congela quando baixo. Flip-flops são acionados por borda: o flip-flop D amostra D na borda do clock e o mantém até a próxima borda — Q após a borda iguala D antes dela.

O flip-flop J-K elimina o estado proibido SR: $J=K=1$ comuta ($Q'$ próximo). A tabela de excitação inverte esse processo — dado uma transição desejada $Q \to Q^+$, lista as entradas necessárias (D: $D = Q^+$; J-K: manter $0{,}0$, definir $1{,}0$, resetar $0{,}1$, alternar $1{,}1$).

Exemplo resolvido 1 (leia o diagrama de temporização). Um flip-flop D vê $D = 1$ no primeiro flanco ascendente, $D = 0$ no segundo, $D = 1$ no terceiro: Q lê 1, 0, 1. Entre bordas, D pode oscilar livremente — nada é amostrado. Diagramas temporais tornam isso visível: Q muda apenas nos instantes de borda. diagramas temporais tornam isso visível: Q muda apenas nos instantes de borda.

Exemplo resolvido 2 (sequência J-K, rastreada na máquina, escalonada). Iniciando partindo de Q = 0, aplique $J,K$ = (1,0), (1,1), (0,1), (0,0). Passo a passo: (1,0) define → 1; (1,1) alterna → 0; (0,1) reseta → 0; (0,0) mantém → 0. Q lê 1, 0, 0, 0 (rastreador de máquina ✓). O design usa: tabelas de excitação executam isso de trás para frente — para construir um contador que vai 0 → 1 → 0 → 0 → 0, leia cada leia cada transição na tabela J-K e as entradas necessárias surgirão (definir, alternar, resetar, manter). A escolha do flip-flop é uma consulta, não um enigma. A escolha do flip-flop é uma consulta, não um enigma.

Erros comuns. Amostragem na borda errada (descendente vs ascendente — a especificação diz qual). Confundir latch e flip-flop: um latch é transparente durante todo o nível, um flip-flop apenas num instante. Esperar que Q mude no momento em que D muda — Q aguarda a borda. Confundir latch e flip-flop: um latch é transparente durante todo o nível, um flip-flop apenas num instante. Esperar que Q mude no momento em que D muda — Q aguarda a borda. Esperar que Q mude no momento em que D muda — Q aguarda a borda. Esperar que Q mude no momento em que D muda — Q aguarda a borda.

Resumo: latches são transparentes ao nível, flip-flops disparados por borda; Q após a borda = D antes dela; J-K remove o estado proibido com alternância; tabelas de excitação invertem o comportamento nas entradas necessárias. latches são transparentes ao nível, flip-flops disparados por borda; Q após a borda = D antes dela; J-K remove o estado proibido com alternância; tabelas de excitação invertem o comportamento nas entradas necessárias. tabelas de excitação invertem o comportamento nas entradas necessárias.

Uma máquina de venda rejeita uma sequência de moedas que aceitou ontem — não porque as moedas mudaram, mas porque a sequência é diferente. Sequências exigem uma máquina com memória de onde está: uma máquina de estados finitos (FSM) é estados + transições: um diagrama de estados (bolhas e rotuladas Sequências exigem uma máquina com memória de onde está: uma máquina de estados finitos (FSM) é estados + transições: um diagrama de estados (bolhas e rotuladas uma máquina de estados finitos (FSM) é estados + transições: um diagrama de estados (bolhas e rotuladas um diagrama de estados (bolhas e rotuladas setas), implementadas como lógica de próximo estado + registradores de estado + lógica de saída. Máquinas de Moore calculam saídas apenas a partir do estado (saídas mudam após o relógio); máquinas de Mealy calculam a partir do estado e das entradas (saídas podem mudar no meio do ciclo, mais rápido mas propensas a ruídos).

Exemplo resolvido 1 (o detector de paridade, rastreado). Ative a saída quando o número de 1 vistos for ímpar. Dois estados (EVEN, ODD); cada bit de entrada alterna entre eles; saída = (estado == ODD). Sequência 1, 0, 1, 1: EVEN → ODD → ODD → EVEN → ODD, logo a saída após o quarto bit é 1 (três 1s vistos — ímpar ✓ máquina rastreada). Procedimento de projeto: diagrama de estados → tabela de estados → (binário) codificação de estados → tabela de excitação para cada flip-flop → minimizar a lógica de próximo estado. Com um bit de estado ($0$ = EVEN, $1$ = ODD) a lógica de próximo estado é uma única XOR: $Q^+ = Q \oplus in$ — a máquina é um bit de paridade.

Exemplo resolvido 2 (o detector de 1011, expandido). Detecte a sequência serial 1011 (com sobreposição). Estados acompanham o prefixo correspondente mais longo: S0 (início), S1 (visto 1), S10 (visto 10), S101 (visto 101). Cada transição vai para a cauda mais longa da entrada até agora que ainda é prefixo de 1011:

De S101, um 1 completa 1011: a saída diz detectado e a máquina vai para S1, porque o "1" final já inicia a próxima correspondência (sobreposição). Uma 0 de S101 deixa "1010", cuja cauda "10" é prefixo, então vai para S10, não voltando a S0. Quatro estados precisam de dois flip-flops ($2^2 = 4$ ✓). Rastreie o fluxo 1,0,1,1,0,1,1: S0→S1→S10→S101→detectar (S1), depois 0→S10, 1→S101, 1→detectar novamente. O fluxo contém duas cópias sobrepostas, nos bits 1–4 e 4–7, e a máquina encontra ambas (rastreador de máquina ✓). Um detector que reinicia em o retorno a S0 após uma correspondência perderia a segunda. Minimização de estados funde estados equivalentes (mesmo saídas, mesmos estados seguintes) — um FSM com estados redundantes funciona, mas gasta flip-flops e lógica.

Erros comuns. Esquecer o reset de sobreposição (um sufixo correspondido é o prefixo da próxima correspondência). Codificar estados antes de verificar a tabela de estados para estados equivalentes. Escolher Moore quando a especificação exige resposta no mesmo ciclo (Mealy), ou Mealy quando as saídas alimentam lógica assíncrona (glitches).

Resumo: estados + transições + saídas; Moore parte do estado, Mealy do estado e entrada; diagrama → tabela → codificação → excitação → minimizar; detecção de sobreposição e fusão de estados são onde se ganham e perdem pontos.

Um placar mostra 7, depois 8 — um número mudou enquanto os demais permaneceram fixos: isso indica atualização seletiva, que é um registro, e a contagem é um registro que atualiza a si mesmo. Um registro é um conjunto de flip-flops com clock comum: carrega n bits por borda. Um registro de deslocamento passa bits adiante: entrada serial saída serial próximo); um contador síncrono aciona todos os clocks a partir de uma única borda e

calcula cada alternância com lógica — sem atraso cumulativo. Exemplo resolvido: um seguinte); um contador síncrono aplica todos os clocks a uma única borda e calcula cada inversão com lógica — sem atraso cumulativo.

Exemplo resolvido 1 (o contador ascendente de 3 bits, traçado). Um contador ascendente síncrono de 3 bits alterna o bit 0 a cada clock, o bit 1 quando $Q_0 = 1$, o bit 2 quando $Q_1\cdot Q_0 = 11$: após RESET, as contagens são 000, 001, 010, 011 … 111, then roll to 000 (8 states = $2^3$ ✓ — the count range check; traçado pela máquina). As condições de alternância são exatamente o AND de todos os bits inferiores — um contador binário transporta quando todos os bits inferiores são 1, que é o que "somar 1" significa.

Exemplo resolvido 2 (um contador mod-6, expandido). Um contador mod-6 conta 000–101 e retorna para 000 — seis estados, não oito. Para uma implementação síncrona, escolha próximo estado 000 quando a palavra atual é 101, 110 ou 111; caso contrário, adicione 1. Rastreio: 000, 001, 010, 011, 100, 101, então 000. Assim 101→000 ocorre na próxima borda do clock; seja código não utilizado 110 ou 111 também recupera para 000 na próxima borda. A condição $Q_2\cdot Q_1$ detecta apenas 110 e 111. É 0 em 101, portanto usar apenas essa condição para escolher próximo estado 000 ainda permitiria armazenar 110 após 101. Limpeza assíncrona é uma implementação diferente: pode brevemente atingir 110 antes de limpar, portanto, não deve ser descrita como este salto síncrono. Memória é uma matriz organizada: k bits de endereço selecionam uma das $2^k$ palavras de m bits — uma memória 8K×8 tem 13 linhas de endereço e 8 linhas de dados ($8K = 2^{13} = 8192$ palavras ✓).

Erros comuns. Contadores em cascata parecem funcionais em baixa velocidade e falham na especificação — o atraso cumulativo é por estágio. Esquecer de tratar os não utilizados estados em contadores mod-N (devem retornar a um estado válido). Confuso convenções de direção de deslocamento (MSB-first vs LSB-first serial).

Resumo: registradores carregam por borda compartilhada; registradores de deslocamento convertem entre serial e paralelo; contadores síncronos calculam comutações com lógica; mod-N requer tratamento de estados não utilizados; memória é $2^k$ palavras de m bits, k linhas de endereço.

Fiar 64 portas manualmente convida 64 erros — e a resposta da indústria não é desenho mais cuidadoso, mas descrição mais verificação. Uma linguagem de descrição de hardware (Verilog/VHDL) descreve estrutura e comportamento como código sintetizável — o que pode se tornar portas — separado do testbench, que simula, mas nunca se torna hardware.

module full_adder(input a, b, cin, output sum, cout);
  assign sum  = a ^ b ^ cin;
  assign cout = (a & b) | (cin & (a ^ b));
endmodule

Exemplo resolvido 1 (o testbench exaustivo). O testbench aciona todas as 8 combinações de entrada e compara contra a verdade aritmética ($a + b + cin = 2\cdot cout + sum$) — verificado por máquina: todas as 8 passam ✓. A propriedade é o ponto: o modelo de referência é aritmético, não outra descrição de porta, então a verificação é independente da implementação.

Exemplo resolvido 2 (um registrador de deslocamento em HDL, expandido). Descreva um registrador de deslocamento serial-entrada de 4 bits: registrador de deslocamento serial-in:

module shift4(input clk, sin, output reg [3:0] q);
  always @(posedge clk) q <= {q[2:0], sin};
endmodule

A concatenação {q[2:0], sin} é o deslocamento — entra pela direita, sai pela esquerda. O testbench aplica sin = 1,0,1,1 por quatro ciclos e o registro mostra q = 0001, 0010, 0101, 1011 ✓ (simulado por máquina) — registrador de deslocamento da unidade 3.6, agora uma descrição de quatro linhas.

Erros comuns. Testbenches que repetem a implementação (uma cópia não prova nada). Construções não sintetizáveis em módulos de hardware. Resets ausentes em bloco always — a armadilha novamente do módulo unitário 3.6.

Resumo: módulo sintetizável versus testbench não sintetizável, sempre separados; o modelo de referência deve ser independente (aritmético ou por traçado); checks exaustivos para espaços de entrada pequenos; entregue os módulos com suas provas.