Circuitos sequenciais: guardar um bit com portas

Circuitos sequenciais: guardar um bit com portas

Todo mundo que já colou um bilhete na geladeira com a frase “não esquecer o leite” conhece a ideia básica de memória. O bilhete não faz conta nenhuma. Ele só diz alguma coisa, e continua dizendo até alguém arrancá-lo ou escrever outro por cima. Se você perguntar “tem leite?” para a geladeira, a resposta depende do que está escrito no papel agora, e não só da pergunta. Circuitos sequenciais são o equivalente elétrico desse bilhete: a saída depende das entradas do momento e também de um estado guardado antes.

A aula anterior, Circuitos combinacionais, tratou do caso oposto. Ali a saída era uma função pura das entradas. Um somador de 64 bits não lembra nada do cálculo anterior, e por isso ele é combinacional. Esta aula acrescenta a peça que falta para um processador funcionar: alguma coisa que guarda um valor entre um ciclo e o seguinte. Sem isso, a CPU não teria registradores, não teria contador de programa e não saberia onde está. O caminho até lá tem três etapas. Primeiro o laço de realimentação, depois o latch, que é o bit mais simples, e por fim o flip-flop, que é o latch com regra de tempo e o que de fato aparece nos chips.

Mapa da aula

1. O que é um circuito sequencial

Um circuito sequencial é aquele cuja saída depende das entradas atuais e também de um estado que ficou guardado de antes. Esse estado é um conjunto de bits que o próprio circuito mantém. Quando as entradas mudam, a saída muda de acordo com as entradas e com o estado, e o novo estado passa a valer para a próxima vez.

A diferença para o combinacional é só essa, mas ela muda tudo o que o circuito consegue fazer. Um somador responde “quanto é 3 mais 5” com a mesma resposta toda vez que as entradas forem 3 e 5. Um contador responde “qual é o próximo número” e a resposta depende de qual era o número anterior, que ele precisa ter guardado. O somador não sabe nada sobre o passado. O contador só existe porque sabe.

O mecanismo que dá memória a um circuito de portas é a realimentação. Numa porta comum, a saída segue a entrada. Quando a saída de uma porta volta, por um fio, para a entrada de outra porta que alimenta a primeira, a informação passa a circular em laço. Se o laço tiver uma forma certa, ele fica parado num de dois estados possíveis e permanece nele enquanto houver alimentação. É isso que vamos montar na seção 4.

Vale fixar uma distinção que vai aparecer o tempo todo. Num combinacional, o tempo entra só como atraso de propagação: a saída demora para estabilizar depois de uma mudança na entrada, mas o resultado final não depende de quando a mudança aconteceu. Num sequencial, o momento importa. Um mesmo sinal de entrada pode ser guardado ou ignorado conforme o instante em que chega, e isso leva a regras de tempo como setup e hold, que aparecem na seção 4.5.

2. Para que serve

Um processador faz muito mais coisas do que somar. Ele precisa lembrar qual instrução está executando, qual é o endereço da próxima, qual valor saiu da última conta e se o último resultado foi zero. Todos esses são estados, e cada um precisa sobreviver até o próximo ciclo de clock. A fase 3 da trilha, CPU, chama esses lugares de registradores e de contador de programa, e sem eles a execução não existe, porque cada instrução depende do resultado da anterior.

Antes de existirem circuitos com memória, a alternativa era tirar o estado de fora do circuito e colocá-lo em outro lugar, como uma fita ou um cartão perfurado. Isso é lento e não serve para um processador. A solução elétrica é fazer o próprio circuito guardar o bit, usando só portas e fios. O resultado é um elemento pequeno, rápido e que cabe milhões de vezes numa pastilha. Um bit de registrador é só um laço de duas ou quatro portas, e um registrador de 64 bits é 64 desses laços lado a lado.

Quando o estado de um circuito precisa ser coordenado com o que os outros circuitos fazem, entra um sinal de tempo chamado clock. O clock diz quando os valores devem ser guardados, e a seção 4.10 mostra apenas a ideia. A aula Circuitos sequenciais não detalha o clock, porque essa tarefa cabe à aula 2.4, que trata de atraso e frequência.

3. Exemplos em contextos diferentes

O primeiro exemplo é o interruptor de luz com duas botoeiras, uma em cada ponta do corredor. Cada botão, sozinho, não diz nada sobre a lâmpada. O que decide a lâmpada é a posição em que o sistema está, e ela só muda quando um botão é apertado. A lâmpada guarda um bit, e os botões são as entradas que o alteram. Esse é um estado puro: apertar o botão duas vezes devolve o mesmo estado de antes, e o sistema precisa lembrar qual é a posição atual para saber o que fazer.

O segundo exemplo é o contador de peças de uma linha de montagem. Cada peça que passa por um sensor soma um ao total. O total é o estado. Se a fábrica desligar a energia, o valor some, e é por isso que contadores de produção costumam ter bateria ou gravam o número em outro lugar. Dentro de um processador, o mesmo tipo de contador conta ciclos, endereços e repetições de laço, e cada um deles precisa guardar o valor de uma contagem para a próxima.

O terceiro exemplo é a fila de um caixa de supermercado que é atendida em ordem. Uma pessoa entra, outra sai, e o tamanho da fila depende de quantas entraram e de quantas saíram até agora. Esse número é um estado acumulado, e a cada chegada ou saída ele muda. Um registrador de deslocamento, que vamos ver na seção 4.7, faz algo parecido com bits: cada pulso empurra o conteúdo uma casa adiante, como uma fila andando.

Os três casos compartilham a propriedade que define o sequencial: a resposta do sistema depende de um estado guardado, e não apenas da entrada do momento. O que os diferencia são os tipos de entrada e o tipo de regra que atualiza o estado.

4. Como funciona

4.1 Dois inversores em anel

Começamos com a forma mais simples de memória que dá para desenhar com portas. Um inversor, ou porta NÃO, tem uma entrada e uma saída, e a saída é sempre o contrário da entrada. Se pegarmos dois inversores e ligarmos a saída do primeiro na entrada do segundo, e a saída do segundo de volta na entrada do primeiro, temos um anel. Chamamos os dois nós de A e B.

Esse anel tem duas configurações que se sustentam sozinhas. Se A for 1, o segundo inversor recebe 1 e entrega 0 em B. Esse 0 volta ao primeiro inversor, que recebe 0 e entrega 1 em A, o que confirma a suposição inicial. Se A for 0, acontece o contrário, e B vira 1. Nas duas situações o anel se fecha consistente, e por isso são chamadas de posições estáveis. O circuito não cai em nenhuma terceira posição consistente, porque, para cada valor de A, o valor de B já está determinado e vice-versa.

A figura abaixo mostra a configuração em que A vale 1 e B vale 0. Os dois fios do anel estão na mesma linha porque o desenho do ArchFlow os traça lado a lado, mas o leitor deve pensar neles como um laço: o fio de cima leva A ao segundo inversor, e o de baixo leva B ao primeiro.

A figura mostra um caso só, e os valores escritos nos rótulos são os que o próprio circuito sustenta. Um olhar rápido já mostra o problema central: nenhum dos dois inversores decide nada sozinho. Cada um só copia o contrário do que recebe, e é o laço que dá ao conjunto o poder de manter um valor.

O anel tem, porém, um defeito grave para memória. Não há entrada nenhuma. Não existe fio pelo qual se possa escrever um bit novo, então o circuito só guarda o que já estava lá quando foi ligado, e não sabemos em qual das duas posições ele cai. Para resolver isso, precisamos de um laço que aceite entradas, e é isso que o latch SR faz.

4.2 Latch SR com portas NOR

Um latch é um circuito sequencial que guarda um bit e muda esse bit por meio de entradas explícitas. O latch SR é o mais simples, e o nome vem das duas entradas: S, de set, que coloca a saída Q em 1, e R, de reset, que a coloca em 0. Uma porta NOR entrega 1 apenas quando as duas entradas são 0. Vista de outro jeito, ela entrega 0 se pelo menos uma das entradas for 1, o que a torna fácil de usar como instrumento de controle.

Construímos o latch com duas portas NOR cruzadas. A saída da primeira, Q, entra na segunda. A saída da segunda, que chamamos de Qn, entra na primeira. A primeira porta recebe R e Qn, e a segunda recebe S e Q. Assim cada saída depende da entrada de controle e da outra saída, e temos o laço de realimentação da seção 4.1 com duas entradas de controle.

A tabela abaixo sai diretamente da lógica da NOR. Se S e R forem ambos 0, cada porta repete a saída da outra, e a combinação de Q e Qn se mantém. Se S for 1 e R for 0, Q vai a 1 e Qn vai a 0, e esse é o estado de set. Se S for 0 e R for 1, o contrário acontece, e temos reset. A combinação S = 1 e R = 1 ao mesmo tempo força as duas portas a entregar 0, e então Q e Qn ficam iguais, o que nunca acontece num latch válido, porque o latch existe justamente para guardar o bit e seu complemento.

Vamos seguir uma sequência de entradas, passo a passo, para ver o latch respondendo. O programa da seção 7 faz exatamente essa conta, com um modelo de atraso unitário: em cada passo, cada porta lê as saídas do passo anterior. Começamos com Q = 0 e Qn = 1, que é o estado depois de um reset. Quando aplicamos S = 1 e R = 0, a primeira porta passa a ver R = 0 e Qn = 1 e entrega 0 em Q. Ao mesmo tempo a segunda porta vê S = 1 e entrega 0 em Qn. No passo seguinte, a primeira porta vê Qn = 0 e R = 0, e entrega 1 em Q, enquanto a segunda vê S = 1 e entrega 0 em Qn. O estado se estabiliza em Q = 1 e Qn = 0. Repare que o set não foi instantâneo: ele levou dois passos, e esse é o atraso de propagação aparecendo no modelo. Depois que S volta a 0, a saída fica em Q = 1, porque o laço se sustenta sozinho.

A tabela de execução do programa mostra o mesmo caminho com os números reais. A primeira linha mostra o set, a segunda o hold com Q = 1, a terceira o reset, e a quarta o hold com Q = 0. A quinta linha é o estado proibido, e a sexta mostra o que acontece quando ele é desfeito, o que discutimos a seguir.

A figura mostra o latch no estado de set. As entradas S e R aparecem como um bloco à esquerda com os dois pinos, e as duas portas NOR recebem essas entradas e a realimentação cruzada. O rótulo de cada porta traz a conta que ela faz naquele momento: a NOR A tem R = 0 e Qn = 0, e entrega Q = 1. A NOR B tem S = 1 e Q = 1, e entrega Qn = 0. Os dois valores são consistentes com a regra da NOR, e por isso o desenho se sustenta.

Há um detalhe que um leitor atento vai perguntar: por que o estado proibido é proibido, e não apenas um caso que dá resultado estranho? A resposta vem quando S e R voltam a 0 ao mesmo tempo. Com Q e Qn ambos em 0 e as duas entradas em 0, cada porta passa a ver 0 e entrega 1. Isso faz Q e Qn irem a 1 juntos. No passo seguinte, ambos viram 0 de novo, e o circuito oscila. No modelo de atraso igual para as duas portas, a oscilação não para. Num circuito real, as portas não têm atraso idêntico, e a que demorar um pouco menos decide o resultado, o que dá um estado final imprevisível. Esse é o motivo de a combinação S = R = 1 ser tratada como entrada proibida. A sexta linha da tabela de execução mostra exatamente essa oscilação, com os valores alternando entre 0 e 1, e a segunda parte do programa mostra que a ordem de liberação decide o resultado.

4.3 Latch SR com portas NAND

Existe uma versão do latch com portas NAND, que entregam 0 apenas quando as duas entradas são 1. Nessa versão as entradas são ativas em nível baixo: o set é S’ = 0 e o reset é R’ = 0, e o apóstrofo indica que a entrada vale quando está em zero. A estrutura do laço é a mesma, com a diferença de que as portas se cruzam do mesmo jeito, mas a condição de ativação é invertida.

Por isso a tabela da versão NAND é diferente da NOR, mesmo com a mesma topologia. Com S’ = 1 e R’ = 1, o latch guarda o valor. Com S’ = 0 e R’ = 1, ele vai a Q = 1, que é o set. Com S’ = 1 e R’ = 0, vai a Q = 0, que é o reset. A combinação proibida agora é S’ = 0 e R’ = 0, que força as duas saídas a 1. Essa diferença aparece em datasheets e em projetos, e é a razão de a mesma palavra “SR” aparecer com regras opostas. Quando você ler um esquema, confira a polaridade das entradas antes de qualquer outra coisa, porque um latch ligado com a polaridade trocada faz o oposto do que se espera.

4.4 Latch D

O latch SR tem um problema prático: as duas entradas precisam ser controladas de modo que nunca fiquem iguais a 1 juntas, e isso dá trabalho para quem usa o circuito. O latch D resolve isso com uma única entrada de dados, D, e uma entrada de habilitação, EN. Quando EN vale 1, a saída Q copia D continuamente. Quando EN vale 0, Q fica guardado e D é ignorado. Esse comportamento de copiar enquanto está habilitado é o que se chama de transparência, e é a propriedade que diferencia o latch do flip-flop.

Por dentro, o latch D é construído com o latch SR. Uma porta NÃO inverte D para gerar o complemento, e duas portas NAND de entrada, uma para D e outra para o complemento de D, são controladas por EN. Essas duas NAND alimentam as entradas de um latch SR NAND, o que garante que as entradas proibidas nunca aparecem: quando EN vale 1, D e seu complemento alimentam o latch de modo que S’ e R’ nunca ficam ambos 0.

A figura abaixo mostra o caso em que EN = 1 e D = 1. A saída da NAND 1 vai a 0, que é o set do latch interno, e a saída Q vai a 1, copiando D. Se você imaginar D mudando para 0 com EN ainda em 1, o latch acompanha a mudança, e Q vai a 0 pouco depois. Esse acompanhamento é a transparência. Agora imagine EN indo a 0. Nesse caso as duas NAND de entrada entregam 1 independentemente de D, o latch interno passa a guardar o valor que tinha, e Q segue parado. Assim o latch copia enquanto está habilitado e guarda quando não está.

Os rótulos das portas mostram o valor de cada uma com EN = 1 e D = 1. A NAND 1 tem S’ = 0, a NAND 2 tem R’ = 1, a NAND 3 entrega Q = 1 e a NAND 4 entrega Qn = 0. A figura é um único caso, mas a lógica é a do latch SR NAND da seção 4.3, e a tabela de verdade do latch D sai daí: com EN = 0 a saída mantém o valor, e com EN = 1 ela assume D.

O latch D já é um elemento de memória útil, mas tem uma fraqueza para circuitos grandes. Enquanto EN está em 1, qualquer ruído ou mudança em D passa para Q. Um circuito de vários blocos em sequência pode ter o dado atravessando vários latches no mesmo instante, e o valor final depende de quanto cada um demora. Para evitar isso, a indústria usa o flip-flop, que captura o dado em um instante só.

4.5 Flip-flop D mestre-escravo

O flip-flop D resolve a transparência do latch com uma ideia simples: usar dois latches D em série, com clocks invertidos. O primeiro, chamado mestre, é transparente quando o clock está em 0. O segundo, chamado escravo, é transparente quando o clock está em 1. Como os dois nunca estão transparentes ao mesmo tempo, o dado não atravessa os dois de uma vez. Quando o clock sobe, o mestre fecha e guarda o valor de D que estava presente nesse instante, e o escravo abre e copia esse valor para a saída. Quando o clock desce, o escravo fecha e guarda, e o mestre volta a acompanhar D, preparando o próximo valor.

A consequência é que a saída Q só muda na borda do clock, e não durante o nível alto. É por isso que o nome do componente é flip-flop: ele muda de estado numa borda, e fica parado no resto do tempo. Uma borda de subida é a transição de 0 para 1 do clock, e a borda de descida é a transição contrária. Um flip-flop pode ser disparado na subida ou na descida, conforme o projeto. Ele é mais útil do que o latch porque um registrador inteiro muda seu conteúdo ao mesmo tempo, na mesma borda, e não gradualmente enquanto um nível está alto.

A tabela de execução do programa da seção 7 mostra esse comportamento, linha por linha. Na linha 2, o clock está em 0 e D passa a 1: o mestre acompanha e vai a 1, mas Q continua em 0, porque o escravo está fechado. Na linha 3, o clock sobe e o escravo copia o valor do mestre, que é 1. Q vai a 1 nessa borda, e não antes. Na linha 4, D cai para 0 com o clock ainda em 1: o mestre está fechado, e Q continua em 1. Na linha 5, o clock desce com D em 0: o mestre acompanha, e Q segue parado. Na linha 6, o clock sobe de novo, o escravo copia o mestre, que é 0, e Q vai a 0. Ou seja, Q assume o valor de D apenas nas bordas de subida, e as mudanças de D entre elas são ignoradas.

A figura mostra o estado em que CLK = 1 logo após a borda de subida. O inversor do clock entrega 0 ao mestre, que está fechado e segura o valor capturado. O escravo recebe CLK = 1 e está aberto, copiando esse valor para a saída. O rótulo do inversor mostra CLK = 1 e saída 0, e as caixas do mestre e do escravo dizem em que nível de clock cada um é transparente. Note que o mestre e o escravo são o mesmo tipo de latch, e a diferença está só no clock que cada um recebe.

Agora precisamos falar de tempo, porque o flip-flop só funciona se o dado estiver estável na hora certa. Duas grandezas controlam isso. O tempo de setup, ou tsu, é o intervalo antes da borda em que o dado precisa estar estável. O tempo de hold, ou th, é o intervalo depois da borda em que o dado precisa continuar estável. A borda captura o que estiver em D nesse instante, e se D mudar dentro da janela formada por esses dois intervalos, a captura falha e a saída pode ficar num valor imprevisível. Uma definição parecida aparece em notas de aula da UCSB, na seção sobre timing de registradores: o setup é o tempo em que o dado de entrada precisa estar válido antes da borda do clock, e o hold é o tempo em que ele precisa continuar válido depois. A fonte dá um exemplo com setup de 210 ps e hold de 0, que é um número de um processo específico e não serve como valor geral.

Por que o mestre-escravo existe e não basta um latch? Porque o latch copia durante todo o nível habilitado, e o flip-flop precisa de um instante de captura. A divisão em mestre e escravo cria esse instante: o mestre fecha na borda e congela o dado, e o escravo só copia o que o mestre congelou. Sem essa separação, o dado poderia atravessar o circuito inteiro durante o nível alto, e a regra de um valor por ciclo se perderia.

O gráfico abaixo mostra as três curvas com os tempos de setup e hold. Ele é ilustrativo: os instantes e os níveis foram escolhidos para mostrar o mecanismo, e não medidos em nenhum circuito. As unidades de tempo são de exemplo, e a janela de 2 unidades antes e 1 depois da borda é apenas uma escolha didática.

Leia o gráfico de cima para baixo: CLK, D e Q. A borda de subida do clock acontece em t = 4, e a janela de captura para ela vai de 2 a 5, com 2 unidades antes e 1 depois, como exemplo. Nessa janela D já está em 1 desde t = 1,5, e continua em 1 até t = 6, então a captura é válida. Q vai a 1 logo depois, em t = 4,5, porque o atraso de propagação faz a saída mudar um pouco depois da borda. Na segunda borda, em t = 12, a janela vai de 10 a 13, e D está em 0 o tempo todo dentro dela, porque só muda para 1 em t = 13,5, depois de encerrado o hold. Por isso Q vai a 0 em t = 12,5. A faixa rosa destaca a janela, e a linha laranja marca a borda.

Nesta figura o atraso de Q, de meia unidade, também é exemplo. Num circuito real esse atraso é outra grandeza, medida em tempo de propagação, e a aula 2.4 trata dela em detalhe. Por ora, o importante é ver que a saída não muda na borda, e sim um pouco depois dela.

4.6 Flip-flops T e JK

Além do D, aparecem nos livros dois outros flip-flops. O T, de toggle, inverte a saída a cada borda de clock quando a entrada T vale 1, e mantém o valor quando T vale 0. Ele é o bloco natural de um contador, porque um contador é um conjunto de bits que alterna a cada pulso. O JK combina set e reset numa só entrada de cada tipo, J e K, e inverte a saída quando as duas valem 1, o que elimina a combinação proibida do latch SR. Nesta aula, o T aparece no contador da seção 4.8, e o JK fica apenas citado. Um flip-flop T pode ser construído a partir de um D com a saída realimentada e invertida, o que mostra que o D basta para tudo, embora não seja o mais econômico em cada caso.

4.7 Registradores

Um registrador é um conjunto de n flip-flops que compartilham o mesmo clock. Cada flip-flop guarda um bit, e juntos formam uma palavra de n bits. Um registrador de 8 bits guarda um byte, e um de 64 bits guarda um inteiro de uma CPU de 64 bits. Como todos os flip-flops recebem a mesma borda, a palavra inteira é atualizada de uma vez, e não bit a bit, o que é o motivo de o registrador ser a peça básica da fase 3.

Muitas vezes o registrador precisa de uma regra para decidir quando carregar um valor novo. Isso se faz com uma habilitação de escrita, que é um multiplexador, ou mux, na entrada de cada flip-flop. O mux escolhe entre duas fontes: quando EN = 1, ele passa o dado de entrada D; quando EN = 0, ele passa de volta a saída Q do próprio flip-flop, o que mantém o valor. Dessa forma, o flip-flop sempre recebe um valor, mas o valor é o mesmo que ele já tinha quando não há escrita. Esse arranjo aparece na figura abaixo.

Vamos resolver um caso concreto. Suponha um registrador de 4 bits com D = 1011, EN = 1 e uma borda de clock. Cada mux passa o bit correspondente de D, e cada flip-flop recebe esse bit na borda. Depois da borda, Q3 = 1, Q2 = 0, Q1 = 1 e Q0 = 1, ou seja, Q3 Q2 Q1 Q0 = 1011, que é 11 em decimal. Se EN for 0 numa borda seguinte com D = 0000, nada muda, e o registrador continua com 1011, porque cada mux devolve a saída atual.

A figura mostra o estado depois da carga de 1011. Cada linha é um bit: um mux à esquerda e um flip-flop à direita, com a saída do flip-flop ligada de volta ao mux, que é o caminho do “manter”. O clock é comum a todos, e o desenho mostra os quatro pinos saindo da caixa do CLK. Um aviso de leitura: o fio de realimentação de cada linha vai do flip-flop de volta ao mux, e o ArchFlow o traça passando por baixo da caixa do flip-flop. Com isso, o desenho não é o layout ideal de uma placa, mas o caminho lógico está certo, e é isso que a figura quer mostrar.

Outro tipo de registrador muda o conteúdo em vez de carregá-lo de uma vez, e é chamado de registrador de deslocamento. Os flip-flops formam uma cadeia, e a saída de cada um alimenta a entrada do seguinte. A cada borda, cada bit passa para a casa seguinte, e um novo bit entra pela primeira casa. Isso é uma conversão de serial para paralelo: os bits chegam um a um por um único fio, e depois de n pulsos estão todos guardados em paralelo, prontos para serem lidos.

Um exemplo concreto: a entrada serial recebe a sequência 1, 0, 1, 1, um bit por pulso, a partir de um registrador vazio. Depois do primeiro pulso, o bit 1 está na casa de entrada. Depois do segundo, esse 1 avança e o 0 entra. Depois do terceiro, a sequência ocupa três casas e o 1 inicial está no meio. Depois do quarto pulso, o primeiro bit, que era 1, está na casa mais distante, Q3, e o último, que também é 1, está em Q0. As casas do meio têm 0 em Q2 e 1 em Q1. Lidos de Q3 até Q0, os valores formam 1011, o mesmo que o registrador de carga guardou de uma vez.

A figura mostra a cadeia depois dos quatro pulsos. A linha de entrada e o clock aparecem agrupados no bloco da esquerda, e cada flip-flop recebe o bit da casa anterior. Os fios animados mostram o caminho que um bit percorre pela cadeia. Os rótulos dos flip-flops trazem o valor final de cada casa, e a leitura de Q3 a Q0 dá 1011.

O deslocamento tem duas vantagens práticas. Uma é a economia de fios: em vez de n fios de dados em paralelo, basta um. A outra é que a cadeia faz multiplicação e divisão por potências de dois quando o deslocamento é feito de um lado ou do outro, um truque que aparece em muitas operações de processador. Não vamos detalhar isso aqui, porque a fase 3 trata das instruções de deslocamento.

4.8 Contador binário: assíncrono e síncrono

Um contador é um registrador cujo valor é o número de pulsos recebidos, e que depois do valor máximo volta a zero. Um contador de 4 bits conta de 0 a 15, e o bit de menor peso, Q0, é o que muda mais depressa, porque alterna a cada pulso. O bit Q1 alterna a metade das vezes, o Q2 a um quarto e o Q3 a um oitavo. A sequência de contagem em binário é a mesma que a de um odômetro, e o programa da seção 7 a exibe pulso a pulso.

Existem duas maneiras de montar esse contador, e elas diferem em como o clock chega a cada bit. A primeira é o contador assíncrono, também chamado de ripple, que é o que a figura abaixo mostra. Cada flip-flop T recebe como clock a saída do flip-flop anterior. Só o primeiro bit é ligado ao clock de entrada. Quando Q0 cai de 1 para 0, ele dispara Q1, que inverte. Quando Q1 cai, dispara Q2, e assim por diante. A contagem se propaga em cadeia, como uma onda, e é por isso que o nome ripple se refere a uma ondulação. A vantagem é que a montagem é simples e usa poucos fios. A desvantagem é que cada bit só muda depois do anterior, e durante o intervalo a leitura do contador mostra valores transitórios. Um circuito que lê o contador no meio dessa onda vê valores que não existem na contagem.

A segunda maneira é o contador síncrono, em que todos os bits recebem o mesmo clock, e um bit alterna somente quando todos os bits menores estão em 1. O bit Q0 alterna sempre. O Q1 alterna quando Q0 vale 1. O Q2 alterna quando Q0 e Q1 valem 1. O Q3 alterna quando os três menores valem 1. A lógica extra é uma cadeia de portas E, e em troca todos os bits mudam na mesma borda, sem onda. O custo é mais portas e um atraso que cresce com o número de bits, porque a cadeia E precisa ser calculada antes da borda. Para contadores de muitos bits, esse atraso pode limitar a frequência, e os projetos reais usam formas mais elaboradas.

O programa da seção 7 confirma que as duas versões dão a mesma sequência nos 16 pulsos, e que o contador volta a 0 depois do pulso 15, com o 16º pulso levando de 15 para 0. A tabela de execução mostra o valor em decimal e em binário de cada bit, ambos para as duas versões lado a lado.

A figura abaixo mostra a versão ripple com o estado 0110, que vale 6. Os bits Q0 a Q3 aparecem nos rótulos dos flip-flops T, e cada flip-flop recebe como clock a saída do anterior. Quando o estado é 6, Q0 = 0, Q1 = 1, Q2 = 1 e Q3 = 0, e o próximo pulso faz Q0 cair e disparar a cascata.

A figura mostra a cadeia no momento em que o contador está em 0110. A próxima descida do clock faz Q0 ir de 0 para 1. Como Q0 subiu, não caiu, nenhum outro bit muda nesse pulso. A cascata só se propaga quando um bit passa de 1 para 0, e isso acontece no pulso seguinte, quando Q0 cai e dispara Q1.

Note que a regra de disparo é na descida do clock de cada estágio, e não na subida. Isso vale para o flip-flop T usado na montagem ripple. Por isso, quando Q0 passa de 1 para 0, é a descida de Q0 que dispara Q1. Essa é a convenção que o programa segue, e a regra vale para o circuito da figura.

O diagrama de tempo abaixo mostra as cinco curvas de um contador ripple de 4 bits em 16 pulsos. Ele é ilustrativo: a figura usa o modelo do programa, com um atraso de 0,3 unidades de tempo por estágio. Esse valor é de exemplo, e não foi medido em nenhum circuito.

Leia a figura de cima para baixo: CLK, Q0, Q1, Q2 e Q3. Q0 alterna a cada pulso, por isso sua curva é a mais densa. Q1 alterna a cada dois pulsos, e Q2 a cada quatro. Q3 muda apenas duas vezes em 16 pulsos: sobe no pulso 8, quando a contagem chega a 1000, e desce no pulso 16, quando volta a 0000. Os degraus de Q1, Q2 e Q3 aparecem um pouco depois dos degraus de Q0, e essa defasagem é o atraso da cascata. É ela que torna a versão ripple mais lenta para ler e mais suscetível a valores transitórios.

4.9 Registradores, SRAM e a memória da fase 4

Os flip-flops guardam bits em silício, mas não são a forma mais barata de guardar muita informação. Um flip-flop D tem muitos transistores, porque o mestre e o escravo são cada um um latch com inversores e chaves. Por isso, a memória de um processador tem duas famílias. Os registradores, que são poucos e ficam dentro da CPU, usam flip-flops e são os mais rápidos. A memória cache, de tamanho médio, costuma usar SRAM, que é uma matriz de células de latch menores. A memória principal, em grande volume, usa DRAM, que guarda carga num capacitor e precisa de atualização periódica.

A célula de SRAM mais usada tem seis transistores e é chamada de 6T. Em alto nível, ela é um latch: dois inversores ligados em anel, como na seção 4.1, guardam o bit, e dois transistores de acesso ligam os nós Q e Qn às linhas de bit, chamadas BL e BL negada. A linha de palavra, WL, controla os acessos. Com WL = 0, os acessos ficam abertos ou fechados conforme a fonte, e a célula apenas mantém o valor. Com WL = 1, os acessos conduzem, e a célula pode ser lida ou escrita pelas linhas de bit. Essa descrição vem de notas de aula da Universidade Estadual de Michigan, que mostram a célula com os modos hold, write e read.

A figura abaixo é uma representação em alto nível da célula, sem os transistores individuais. Os dois inversores são portas NÃO, e os acessos são chaves. A linha WL não aparece como fio, porque a chave do ArchFlow não tem pino de controle, e o rótulo dos acessos diz que a condição é WL = 0.

A figura mostra o caso de repouso, em que WL = 0 e os acessos estão abertos. Os inversores estão em anel, como na seção 4.1, e cada nó tem uma ligação para as bitlines pelo acesso correspondente. O rótulo de cada inversor mostra o valor guardado: Q = 1 e Qn = 0. Para ler, a linha WL sobe, o acesso conduz e a diferença de tensão entre BL e BL negada é percebida por um amplificador de leitura. Para escrever, WL também sobe, e as bitlines são forçadas ao novo valor, sobrescrevendo o que a célula tinha.

Um ponto que a aula não confirmou por fonte primária é o tempo que a célula mantém o bit sem alimentação ou sem atualização. O laço de inversores mantém o valor enquanto houver energia, e isso é o que distingue a SRAM da DRAM, mas a aula não mediu nem citou um tempo de retenção. Está na seção de limitações.

Por que essa conexão importa para a trilha? Porque a fase 4 trata de hierarquia de memória, e a cache é feita de SRAM. A diferença de velocidade entre registrador, cache e RAM, que a fase 4 explica com números, nasce da forma como cada uma guarda o bit. Quanto mais perto do núcleo fica a memória, mais ela é feita de latches com pouca lógica ao redor, e mais rápido é o acesso. A figura abaixo mostra onde os registradores aparecem dentro da CPU, e a aula da fase 4 vai ampliar a parte da cache.

Para dar uma visão do que vem depois, a figura abaixo mostra onde os registradores ficam dentro de um núcleo de CPU, em relação à ULA e à cache. O objetivo é apenas situar o leitor: cada bloco é tratado com profundidade na fase correspondente da trilha.

A figura mostra o caminho que um dado percorre. A RAM entrega linhas de cache para a L1, e a L1 troca valores com o banco de registradores por instruções de load e store. Os registradores fornecem os operandos para a ULA, que devolve o resultado de volta a um registrador. A unidade de controle envia os sinais de operação para a ULA. O contador de programa não aparece ligado a nada, de propósito: ele é um registrador especial que guarda o endereço da instrução atual, e a fase 3 trata dele em detalhe.

4.10 O que o clock coordena

Um circuito sequencial precisa de alguma forma de saber quando guardar. Esse papel cabe ao clock, um sinal periódico que alterna entre 0 e 1 e serve de referência para todas as bordas. Num sistema síncrono, todos os flip-flops recebem a mesma borda, e o estado do circuito muda inteiro de uma vez. Isso simplifica o raciocínio, porque o estado é sempre atualizado em instantes conhecidos. A alternativa assíncrona, em que cada bloco decide por conta própria quando muda, existe, mas é difícil de projetar e de depurar.

O clock também impõe um limite. Para que todos os flip-flops capturem o valor certo, o caminho lógico entre dois registradores precisa estabilizar antes da próxima borda, e a soma de atrasos determina a frequência máxima. Essa é a razão de o tempo de setup aparecer nesta aula, e de a aula 2.4 tratar do clock e do atraso de propagação. Aqui basta a ideia: o clock é a referência de tempo que coordena o estado, e a regra de setup e hold é a condição para que a referência funcione.

5. Detalhes e bordas

O primeiro detalhe é a entrada proibida do latch SR. A combinação S = R = 1 na NOR, ou S’ = R’ = 0 na NAND, não gera um estado válido. O programa mostra o caso em que as duas entradas são soltas juntas, e a saída oscila. Quando uma entrada é solta antes da outra, o resultado depende de qual saiu primeiro, e o programa confirma os dois casos. Isso significa que um projeto de latch SR precisa garantir, por lógica externa, que as duas entradas nunca fiquem ativas ao mesmo tempo. Esse é o motivo de o latch D existir: ele gera internamente as entradas do SR de modo que a combinação proibida nunca aparece.

O segundo detalhe é a metaestabilidade. Quando o tempo de setup ou de hold é violado, o flip-flop pode entrar num estado intermediário, nem 0 nem 1, e permanecer nele por um tempo imprevisível antes de cair para um dos dois valores. Notas da Universidade de Maryland descrevem a violação do setup e do hold como uma situação que pode levar o latch ao seu estado metaestável. Um circuito real lida com isso com sincronizadores, que são dois flip-flops em série com o primeiro absorvendo a instabilidade. A aula não detalha o sincronizador, e a aula 2.4 pode retomá-lo.

O terceiro detalhe é o atraso que a saída tem em relação à borda. No gráfico da seção 4.5, Q muda um pouco depois da borda, e esse atraso se soma ao caminho lógico seguinte. Num registrador que alimenta outro, o caminho inteiro precisa caber num período de clock. Quando um projeto não cabe, a frequência cai.

O quarto detalhe é a leitura do contador ripple no meio da cascata. Como os bits mudam em sequência, um circuito que lê o contador logo após a borda pode ver uma combinação que não existe na contagem. A figura 09 mostra os degraus defasados, e é essa defasagem que cria os valores transitórios. A solução prática é ler o contador só quando a cascata terminou, ou usar a versão síncrona.

O quinto detalhe é a comparação com as alternativas. Um latch SR é o elemento mais simples e serve para entender o princípio. Um latch D é mais cômodo para usar, mas é transparente e precisa de controle cuidadoso. O flip-flop D mestre-escravo é o padrão para registradores, porque captura numa borda. O flip-flop T é o bloco natural de contadores, e o JK é uma alternativa ao D com a combinação proibida eliminada. A escolha depende do que o circuito precisa fazer, e os livros de projeto digital comparam essas variantes com tabelas de caracterização.

6. Erros comuns e boas práticas

O erro mais frequente é tratar o latch como se fosse o flip-flop. Quem liga um latch D a um sinal que muda enquanto EN está alto vê a saída seguir cada oscilação, e acha que o circuito está quebrado. Ele não está: o latch está fazendo o que foi projetado, copiando enquanto habilitado. A correção é trocar por um flip-flop quando o objetivo é capturar um valor num instante. Todo mundo que confunde os dois esquece, uma vez, que o latch é transparente, e quem diz que nunca esqueceu ainda não depurou um registrador numa sexta-feira.

O segundo erro é esquecer a polaridade das entradas. Um latch SR NAND com entradas ativas em zero, quando ligado como se fosse NOR, faz exatamente o oposto do que o projetista imagina. A boa prática é escrever a tabela de estados antes de montar o circuito e conferir, linha por linha, qual entrada liga e qual desliga a saída.

O terceiro erro é mudar a entrada de um flip-flop perto da borda. Se D muda dentro da janela de setup ou de hold, a captura pode falhar e o valor fica incerto. Em projeto real, a ferramenta de síntese verifica essas janelas, mas quem escreve o desenho à mão precisa lembrar a regra. A boa prática é garantir que o dado de entrada venha de um flip-flop da mesma borda, para que ele mude sempre depois do hold.

O quarto erro é ler um contador ripple como se ele fosse síncrono. Como a cascata leva um tempo, a leitura no meio da contagem pode mostrar um valor que não existe. A boa prática é ler o contador apenas quando a cascata estabilizou, ou escolher o contador síncrono quando a leitura é frequente.

O quinto erro é confundir o registrador de carga com o de deslocamento. Os dois guardam quatro bits, mas o primeiro recebe os quatro de uma vez e o segundo os recebe um por pulso. Se você projeta um sistema que espera receber um byte inteiro e liga um registrador de deslocamento, ele vai guardar a sequência, mas no formato errado para o resto do sistema.

Uma boa prática geral é separar o que o circuito guarda do que ele calcula. Um somador ligado a um registrador forma um acumulador, que é o padrão de muitos processadores. Quando o estado e a lógica estão claramente separados, o circuito fica mais fácil de testar e de explicar.

7. O programa que simula

O programa abaixo implementa cada circuito a partir de portas, com NOT e NOR como funções, e executa a sequência de entradas e os pulsos de clock. O modelo é de atraso unitário: em cada passo, cada porta lê as saídas do passo anterior. Esse modelo basta para mostrar o comportamento e a oscilação, mas não mede tempo real de porta. A primeira parte simula o latch SR com NOR e a sequência da seção 4.2, incluindo o estado proibido. A segunda parte mostra que a ordem de liberação das entradas decide o resultado. A terceira simula o flip-flop D mestre-escravo. A quarta simula o contador de 4 bits nas versões ripple e síncrona, em 16 pulsos.

O programa foi executado com Python 3.12.8, no modo isolado, com o comando python3 -I sequenciais.py. A saída abaixo é a real, copiada do terminal sem edição.

# Simulação didática de circuitos sequenciais, construídos só com portas.
# Modelo de atraso unitário: em cada passo, cada porta lê as saídas do passo anterior.

def NOT(a):
    return 1 - a

def NOR(a, b):
    return 1 - (a | b)

def estabiliza(s, r, q, qb, max_passos=4):
    # Aplica S e R ao latch SR de duas portas NOR e repete o passo até parar ou esgotar o limite.
    trilha = [(q, qb)]
    for _ in range(max_passos):
        novo_q = NOR(r, qb)
        novo_qb = NOR(s, q)
        if (novo_q, novo_qb) == (q, qb):
            return (q, qb), trilha, "estavel"
        q, qb = novo_q, novo_qb
        trilha.append((q, qb))
    return (q, qb), trilha, "oscila"

def texto_trilha(trilha):
    return " -> ".join("Q=%d Qb=%d" % t for t in trilha)

print("== 1. latch SR com duas portas NOR ==")
q, qb = 0, 1  # estado depois de um reset
sequencia = [(1, 0), (0, 0), (0, 1), (0, 0), (1, 1), (0, 0)]
for s, r in sequencia:
    (q, qb), trilha, situacao = estabiliza(s, r, q, qb)
    aviso = "  <- PROIBIDO: Q e Qb iguais" if q == qb else ""
    print("S=%d R=%d | %-7s | %s%s" % (s, r, situacao, texto_trilha(trilha), aviso))

print("== 2. S=R=1 seguido de liberação, uma entrada de cada vez ==")
for nome, passos in [("S solta primeiro", [(0, 1), (0, 0)]),
                     ("R solta primeiro", [(1, 0), (0, 0)])]:
    q, qb = 0, 0  # estado proibido, com S=R=1
    for s, r in passos:
        (q, qb), trilha, situacao = estabiliza(s, r, q, qb)
    print("%-17s -> Q=%d Qb=%d (%s)" % (nome, q, qb, situacao))

print("== 3. flip-flop D mestre-escravo ==")

def latch_nivel(entrada, habilitado, guardado):
    # Latch transparente: copia a entrada enquanto está habilitado, e guarda o valor quando não está.
    return entrada if habilitado else guardado

mestre, q = 0, 0
sinais = [(0, 0), (0, 1), (1, 1), (1, 0), (0, 0), (1, 0)]  # pares (clk, d) em ordem de tempo
print("t  clk d | mestre q")
for t, (clk, d) in enumerate(sinais):
    mestre = latch_nivel(d, clk == 0, mestre)   # mestre transparente com clk = 0
    q = latch_nivel(mestre, clk == 1, q)        # escravo transparente com clk = 1
    print("%d   %d   %d |   %d     %d" % (t, clk, d, mestre, q))

print("== 4. contador de 4 bits ==")

def pulso_ripple(bits):
    # bits[0] é o menos significativo. Cada estágio é um T, e o clock de cada um é a saída do anterior.
    bits = list(bits)
    bits[0] ^= 1
    i = 0
    while i < 3 and bits[i] == 0:
        bits[i + 1] ^= 1
        i += 1
    return bits

def pulso_sincrono(bits):
    # Todos os bits recebem o mesmo clock. Cada bit alterna só se todos os menores estavam em 1.
    novo = list(bits)
    habilita = 1
    for i in range(4):
        if habilita:
            novo[i] ^= 1
        habilita = habilita & bits[i]
    return novo

def valor(bits):
    return sum(b << i for i, b in enumerate(bits))

def binario(bits):
    return "".join(str(b) for b in reversed(bits))

ripple = [0, 0, 0, 0]
sinc = [0, 0, 0, 0]
iguais = True
for k in range(16):
    print("pulso %2d: ripple %2d (%s)   sincrono %2d (%s)" % (
        k, valor(ripple), binario(ripple), valor(sinc), binario(sinc)))
    if ripple != sinc:
        iguais = False
    ripple = pulso_ripple(ripple)
    sinc = pulso_sincrono(sinc)
print("depois do pulso 15, o 16o pulso leva ripple a %d (%s) e sincrono a %d (%s)" % (
    valor(ripple), binario(ripple), valor(sinc), binario(sinc)))
print("ripple e sincrono iguais nos 16 pulsos:", iguais)

Saída real do programa, com Python 3.12.8:

== 1. latch SR com duas portas NOR ==
S=1 R=0 | estavel | Q=0 Qb=1 -> Q=0 Qb=0 -> Q=1 Qb=0
S=0 R=0 | estavel | Q=1 Qb=0
S=0 R=1 | estavel | Q=1 Qb=0 -> Q=0 Qb=0 -> Q=0 Qb=1
S=0 R=0 | estavel | Q=0 Qb=1
S=1 R=1 | estavel | Q=0 Qb=1 -> Q=0 Qb=0  <- PROIBIDO: Q e Qb iguais
S=0 R=0 | oscila  | Q=0 Qb=0 -> Q=1 Qb=1 -> Q=0 Qb=0 -> Q=1 Qb=1 -> Q=0 Qb=0  <- PROIBIDO: Q e Qb iguais
== 2. S=R=1 seguido de liberação, uma entrada de cada vez ==
S solta primeiro  -> Q=0 Qb=1 (estavel)
R solta primeiro  -> Q=1 Qb=0 (estavel)
== 3. flip-flop D mestre-escravo ==
t  clk d | mestre q
0   0   0 |   0     0
1   0   1 |   1     0
2   1   1 |   1     1
3   1   0 |   1     1
4   0   0 |   0     1
5   1   0 |   0     0
== 4. contador de 4 bits ==
pulso  0: ripple  0 (0000)   sincrono  0 (0000)
pulso  1: ripple  1 (0001)   sincrono  1 (0001)
pulso  2: ripple  2 (0010)   sincrono  2 (0010)
pulso  3: ripple  3 (0011)   sincrono  3 (0011)
pulso  4: ripple  4 (0100)   sincrono  4 (0100)
pulso  5: ripple  5 (0101)   sincrono  5 (0101)
pulso  6: ripple  6 (0110)   sincrono  6 (0110)
pulso  7: ripple  7 (0111)   sincrono  7 (0111)
pulso  8: ripple  8 (1000)   sincrono  8 (1000)
pulso  9: ripple  9 (1001)   sincrono  9 (1001)
pulso 10: ripple 10 (1010)   sincrono 10 (1010)
pulso 11: ripple 11 (1011)   sincrono 11 (1011)
pulso 12: ripple 12 (1100)   sincrono 12 (1100)
pulso 13: ripple 13 (1101)   sincrono 13 (1101)
pulso 14: ripple 14 (1110)   sincrono 14 (1110)
pulso 15: ripple 15 (1111)   sincrono 15 (1111)
depois do pulso 15, o 16o pulso leva ripple a 0 (0000) e sincrono a 0 (0000)
ripple e sincrono iguais nos 16 pulsos: True

Leia a primeira parte da saída com a tabela da seção 4.2 ao lado. A linha do S = 1 R = 0 mostra o estado passando por Q = 0, Qn = 0 antes de chegar a Q = 1, Qn = 0, que é o atraso de propagação do modelo. A linha S = 1 R = 1 marca o estado proibido com o aviso. A última linha da primeira parte mostra a oscilação: quando S e R voltam a 0 a partir do estado proibido, os valores alternam entre 0 e 1 e nunca param. A segunda parte mostra que, com a liberação em ordens diferentes, o resultado é Q = 0 ou Q = 1, conforme a entrada que sai primeiro. A terceira parte é a tabela do flip-flop, que reproduz linha por linha o comportamento explicado na seção 4.5. A quarta parte mostra a contagem de 0 a 15 nas duas versões, que dão a mesma sequência, e a volta a 0 no 16º pulso.

8. Exercícios

1. No latch SR com NOR, parta de Q = 0 e Qn = 1. Aplique S = 0 e R = 1, e depois S = 0 e R = 0. Qual é o valor final de Q? Resposta: com S = 0 e R = 1, a primeira porta entrega 0 em Q e a segunda entrega 1 em Qn. Com S = 0 e R = 0 depois, o laço se sustenta e Q continua em 0. O valor final é Q = 0, que é o reset guardado.

2. Um latch SR tem entradas ativas em zero (NAND). Qual combinação de S’ e R’ é proibida, e por quê? Resposta: S’ = 0 e R’ = 0 ao mesmo tempo. As duas portas NAND então entregam 1 em Q e Qn, o que quebra a regra de que as duas saídas são complementares.

3. Um registrador de deslocamento de 4 bits, começando vazio, recebe a entrada serial 0, 1, 1, 0, um bit por pulso. Qual é o valor em Q3 a Q0 depois de quatro pulsos? Resposta: o primeiro bit, 0, ficou em Q3, e o último, 0, ficou em Q0. O segundo, 1, ficou em Q2 e o terceiro, 1, ficou em Q1. Lido de Q3 a Q0, o valor é 0110, que é 6 em decimal.

4. Um contador ripple de 4 bits está em 1011 (11). Quantos pulsos são necessários para voltar a 0000, e qual é o valor depois de 5 pulsos? Resposta: são 5 pulsos, porque 11 mais 5 dá 16, e a contagem de 4 bits volta a zero módulo 16. Depois de 5 pulsos, o valor é 0000.

5. Um flip-flop D tem, no exemplo da seção 4.5, setup de 2 unidades e hold de 1. D muda para 0 no instante 10,5, e a borda de subida está em 12. A captura é válida? Resposta: não. A janela de setup vai de 10 a 12. A mudança em 10,5 cai dentro dessa janela, então o dado não está estável durante o tempo de setup, e a captura é inválida. Os valores são de exemplo.

6. No contador ripple do modelo da seção 4.8, cada estágio atrasa 0,3 unidade de tempo em relação ao anterior. Em quanto tempo, depois da descida do clock, Q3 muda? Resposta: Q0 muda 0,3 depois da descida, Q1 muda 0,3 depois de Q0, Q2 muda 0,3 depois de Q1 e Q3 muda 0,3 depois de Q2. O total é 4 vezes 0,3, ou seja, 1,2 unidade de tempo depois da descida do clock. O valor é de exemplo, porque vem do modelo.

9. Glossário

Circuito sequencial: circuito cuja saída depende das entradas atuais e de um estado guardado antes.

Realimentação: ligação em que a saída de um circuito volta à sua entrada, por um caminho que forma um laço.

Posição estável: estado em que um laço realimentado se sustenta sem mudar enquanto as entradas não mudam.

Latch: circuito que guarda um bit e muda esse bit por entradas de controle, enquanto um nível de habilitação está ativo.

Latch SR: latch com entradas de set e reset, em que a combinação de ambas ativas é proibida.

Transparência: propriedade de um latch que copia a entrada para a saída enquanto está habilitado.

Flip-flop: elemento que captura o valor de sua entrada numa borda do clock e o mantém até a borda seguinte.

Mestre-escravo: flip-flop formado por dois latches em série com clocks invertidos, que captura na borda.

Borda de subida: transição do clock de 0 para 1.

Setup: intervalo antes da borda em que o dado precisa estar estável.

Hold: intervalo depois da borda em que o dado precisa continuar estável.

Metaestabilidade: estado intermediário de um flip-flop depois de uma violação de setup ou hold, em que a saída fica indefinida por um tempo.

Registrador: conjunto de flip-flops com o mesmo clock, que guarda uma palavra de n bits.

Registrador de deslocamento: registrador em que cada bit passa para a casa seguinte a cada pulso.

Contador ripple: contador assíncrono em que o clock de cada estágio é a saída do anterior.

Contador síncrono: contador em que todos os bits recebem o mesmo clock.

SRAM: memória estática feita de células de latch, que guarda o bit enquanto houver energia.

Célula 6T: célula de SRAM com seis transistores, dois inversores e dois acessos.

O que não foi confirmado ou medido

Os programas desta aula foram executados e as saídas são reais. Eles verificam a lógica dos circuitos contra a sequência esperada, mas não simulam tensão, corrente, nem tempo real de porta. O modelo de atraso unitário é uma convenção de simulação, e não uma medida.

Os gráficos das figuras 05 e 09 são ilustrativos. Os instantes, os níveis e os atrasos de 0,3 unidade por estágio foram escolhidos para mostrar o mecanismo. As unidades de tempo são de exemplo e não correspondem a nanossegundos de nenhum processo de fabricação.

Os valores de setup de 2 unidades e de hold de 1 unidade são de exemplo. O exemplo de 210 ps e hold de 0 vem de notas da UCSB e é um número de um processo específico. A aula não confirmou valores de setup e hold de nenhum componente comercial.

A descrição do contador ripple como cascata de flip-flops T disparados na descida do clock segue a convenção do modelo do programa. A aula não consultou uma fonte primária nesta sessão que confirmasse essa convenção de borda para cada família de circuitos integrados, e por isso ela deve ser lida como descrição do modelo.

A descrição da célula 6T vem de notas de aula da Universidade Estadual de Michigan, que confirmam os modos hold, write e read. A aula não confirmou por fonte o tempo de retenção da célula sem atualização nem a corrente de leitura, e não citou números desses parâmetros.

As figuras de circuito são representações em nível de portas e de blocos. Elas não mostram transistores, a não ser de forma simbólica na célula de SRAM, e não representam o caminho elétrico real. A figura do registrador de carga desenha o fio de realimentação passando por baixo da caixa do flip-flop, por limitação do traçado automático, e o caminho lógico está correto.

A aula não cobre sincronizadores em detalhe, nem o flip-flop JK, nem a análise completa de tempo de propagação. Esses assuntos ficam para a aula 2.4 e para as fases seguintes da trilha.

Fontes

Consultadas em 1 de novembro de 2026.

• Columbia University, CSEE 3827, slides “Latches and Flip Flops”, sobre o latch SR com portas NOR e as entradas inválidas: http://www.cs.columbia.edu/~martha/courses/3827/sp10/slides/5_latchesFlipFlops.pdf
• University of Maryland, ENEE 244, notas da aula 18, sobre setup, hold, latch D transparente e mestre-escravo, incluindo a menção ao estado metaestável: https://user.eng.umd.edu/~danadach/ENEE_244_Fall_15/lec_18_notes.pdf
• University of California, Santa Barbara, ECE 122A, aula 15 (Prof. Kaustav Banerjee), sobre as definições de tsu, thold e tempo de propagação do registrador, e o exemplo de 210 ps: https://courses.ece.ucsb.edu/ECE122/122_F22Banerjee/Slides/Lecture_15.pdf
• Michigan State University, ECE 410, notas do Prof. A. Mason, Lecture 13.2, sobre a célula SRAM 6T, os modos hold, write e read, e a função da linha WL: https://www.egr.msu.edu/classes/ece410/mason/files/Ch13.pdf

As fontes acima confirmam as definições de latch SR, latch D, mestre-escravo, setup, hold, metaestabilidade e a célula 6T. A regra de disparo do contador ripple, o atraso de 0,3 por estágio e os valores de exemplo são do modelo desta aula, e não foram copiados de nenhuma fonte.

Relacionados

• Trilha de Hardware
• CPU
• Circuitos combinacionais
• Transistor como chave
• Álgebra booleana e portas lógicas
• Bits e binário