Questão 02 Em braços robóticos e sistemas CNC (Comando Numérico Computadorizado), a posição angular de um eixo é rastreada por um encoder incremental. O encoder gera pulsos digitais: ao girar no sentido horário, o controlador incrementa o contador; ao girar no sentido anti-horário, o contador é decrementado. O valor acumulado representa a posição absoluta do eixo em relação a um ponto de referência (home). Um contador Up/Down síncrono de 3 bits é utilizado nesse sistema.
a) Explique o princípio de funcionamento do contador Up/Down:
i) O que diferencia a contagem crescente da decrescente no nível dos flip-flops JK? Mencione o papel das saídas Q e \bar{Q}.
ii) Qual sinal de controle seleciona o modo de operação? Como ele atua no circuito para alternar entre os dois modos?
iii) Por que é necessário usar portas lógicas adicionais (além dos FFs ) nesse tipo de contador?
b) Complete a tabela de estados do contador Up/Down de 3 bits conforme a sequência de operações descrita. O eixo robótico parte do ponto de referência (home =000 ):
Evento Modo Q_{C} Q_{B} Q_{A} Posição (decimal)
Inicial (home) - 0 0 0 0
Pulso 1 Up
Pulso 2 Up
Pulso 3 Up
Pulso 4 Up
Pulso 5 Down
Pulso 6 Down
Pulso 7 Up
Pulso 8 Up
O eixo mudou de direção nos pulsos 5-6 e voltou a avançar nos pulsos 7-8. Qual é a posição final do eixo?

Passo 1

O enunciado pede duas coisas principais:
  • (a) Explicar o princípio de funcionamento de um contador Up/Down síncrono de 3 bits, respondendo:
    i) O que diferencia a contagem crescente da decrescente no nível dos flip-flops JK, mencionando o papel das saídas \,Q e \bar{Q}\,.
    ii) Qual sinal de controle seleciona o modo de operação e como ele atua no circuito para alternar entre os modos.
    iii) Por que são necessárias portas lógicas adicionais além dos flip-flops.
  • (b) Preencher a tabela de estados para um contador de 3 bits que parte de \,000 (home) e recebe a sequência de pulsos indicada (pulsos 1 a 8) com mudanças de direção nos pulsos 5–6 e depois volta a subir nos pulsos 7–8. Pergunta final: qual é a posição final do eixo?
Informações dadas:
  • Contador síncrono Up/Down de 3 bits (bits chamados \,Q_C (MSB), \,Q_B, \,Q_A (LSB),).
  • Partida em \,000 (decimal \,0).
  • Pulsos 1–4: modo Up.
  • Pulsos 5–6: modo Down.
  • Pulsos 7–8: modo Up.
  • O encoder gera um pulso por passo; cada pulso provoca uma transição síncrona (todos os FFs são acionados pelo mesmo clock).

Passo 2

Breve aula sobre o flip-flop JK (o “motor” deste contador).
  • Um flip-flop JK tem duas entradas J e K, e saídas \,Q e \bar{Q}.
  • A tabela de funcionamento (no pulso de clock, assumindo operação sem condições de corrida) é:
    • J=0,\\ K=0 \Rightarrow manter o estado (hold).
    • J=1,\\ K=0 \Rightarrow forçar Q\leftarrow 1 (set).
    • J=0,\\ K=1 \Rightarrow forçar Q\leftarrow 0 (reset).
    • J=1,\\ K=1 \Rightarrow toggling: Q\leftarrow\bar{Q} (inverte).
  • Usar J=K=1 é a forma mais simples de pedir que o bit “troque” no próximo clock; então um contador normalmente gera para cada FF um sinal que põe J=K=1 exatamente quando aquele bit precisa ser invertido no pulso.
  • Papel de \,Q e \bar{Q}: essas duas saídas providenciam tanto o valor direto do bit quanto seu complemento. As portas lógicas externas usam \,Q e \bar{Q} para detectar padrões (por exemplo, “todos os bits inferiores valem 1” ou “todos valem 0”), e assim decidir se cada flip-flop deve togglar. Ou seja, \,Q detecta 1s e \bar{Q} detecta 0s.

Passo 3

Princípio do contador síncrono Up/Down (visão prática e fórmulas).
  • Em contagem binária:
    • O bit menos significativo \,Q_A troca (toggle) a cada pulso de clock — ele sempre alterna entre 0 e 1. Portanto para ele definimos J_A=K_A=1.
    • O bit \,Q_B deve trocar quando todos os bits com peso menor do que ele satisfizerem uma certa condição:
      • No modo Up: \,Q_B toggla quando \,Q_A=1 (ou seja, quando o LSB passa de 1 para 0 com carry).
      • No modo Down: \,Q_B toggla quando \,Q_A=0 (borrowing, quando ao decrementar o LSB é 0).
    • O bit \,Q_C (MSB) toggla quando os dois bits inferiores estiverem em condição que cause carry/borrow:
      • No modo Up: quando \,Q_B=1 e \,Q_A=1.
      • No modo Down: quando \,Q_B=0 e \,Q_A=0.
  • Introduzindo um sinal de direção \,S: defina \,S=1 para Up e \,S=0 para Down. Então as condições de toggle (que colocam J=K=1) podem ser escritas:
    • Para \,A: J_A = K_A = 1.
    • Para \,B: J_B = K_B = S\cdot Q_A + \bar{S}\cdot \bar{Q_A}.(Se S=1 usa-se Q_A; se S=0 usa-se \bar{Q_A}.)
    • Para \,C: J_C = K_C = S\cdot (Q_B Q_A) + \bar{S}\cdot (\bar{Q_B}\,\bar{Q_A}).(No modo Up detecta-se Q_BQ_A=1, no modo Down detecta-se \bar{Q_B}\bar{Q_A}=1.)
  • Explicação da forma: onde aparece Q_B Q_A entende-se \,Q_B \land Q_A (AND). Onde aparece \bar{Q_B}\bar{Q_A} é AND dos complementos (detecta ambos iguais a zero). A soma + é OR lógico (multiplexagem controlada por \,S).

Passo 4

Como o sinal de controle \,S atua no circuito (intuitivo):
  • \,S funciona como um seletor (multiplexador) nas portas que geram os sinais J e K. Ele escolhe entre usar sinais que detectam “todos os bits inferiores são 1” (caso Up) ou “todos são 0” (caso Down).
  • Fisicamente \,S entra em ANDs/ORs que combinam \,Q e \bar{Q} para formar as condições de toggle do modo desejado. Por exemplo, para J_B o circuito pode ser:
    • Um AND que gera A_{\text{up}} = Q_A.
    • Um AND que gera A_{\text{down}} = \bar{Q_A}.
    • Um multiplexador controlado por S que seleciona A_{\text{up}} quando S=1 ou A_{\text{down}} quando S=0; a saída desse mux vai para J_B e K_B.
  • Como todos os FFs recebem o mesmo clock (síncrono), as decisões são calculadas antes do clock e aplicadas simultaneamente quando o pulso de clock chega.

Passo 5

Por que são necessárias portas lógicas adicionais (além dos FFs)?
  • Os flip-flops fornecem apenas seus sinais \,Q e \bar{Q}. Para decidir se um FF deve togglar é preciso detectar padrões complexos (ex.: \,Q_BQ_A=1 ou \,\bar{Q_B}\bar{Q_A}=1), o que exige ANDs, ORs e inversores. Assim:
    • São necessárias portas AND para detectar que vários bits inferiores estão todos em 1 (ou todos em 0 usando \bar{Q}).
    • É preciso uma porta OR para combinar as condições do modo Up e do modo Down (multiplexagem baseada em \,S).
    • Sem essas portas não há como derivar os sinais J e K corretos a partir das saídas dos flip-flops.
  • Além disso, essas portas permitem evitar problemas de ripple (no contador síncrono não há ripple porque a lógica é avaliada antes do clock), e ajudam a respeitar tempos de setup/hold: calcula-se a condição e em seguida o clock atualiza todos os FFs ao mesmo tempo.

Passo 6

Método de preenchimento da tabela: cada pulso atualiza os bits de acordo com o modo naquele pulso. Vou computar estado por estado (mostrando por que cada bit muda).
Estado inicial (home): \,Q_CQ_BQ_A = 000 (decimal \,0) — já dado na tabela.

Passo 7

Pulso 1 — modo Up ( S=1).
  • Incrementa \,000 \to 001.
  • Raciocínio: LSB \,Q_A sempre toggle. \,Q_B não toggle porque em Up ele toggla só se Q_A=1 (antes do pulso Q_A=0). \,Q_C também não.
  • Resultado: \,Q_C=0,\\ Q_B=0,\\ Q_A=1. Posição decimal \,1.

Passo 8

Pulso 2 — modo Up.
  • Incrementa \,001 \to 010.
  • Raciocínio: \,Q_A toggle 1\to0. Como Q_A era 1, Q_B deve toggle (0\to1). Q_C não (porque agora Q_B Q_A antes do pulso era 0\cdot1=0).
  • Resultado: \,Q_C=0,\\ Q_B=1,\\ Q_A=0. Posição decimal \,2.

Passo 9

Pulso 3 — modo Up.
  • Incrementa \,010 \to 011.
  • Raciocínio: \,Q_A toggle 0\to1. Q_B não toggle porque em Up toggla só quando Q_A era 1 antes do clock (aqui era 0). Q_C não.
  • Resultado: \,Q_C=0,\\ Q_B=1,\\ Q_A=1. Posição decimal \,3.

Passo 10

Pulso 4 — modo Up.
  • Incrementa \,011 \to 100.
  • Raciocínio: \,Q_A toggle 1\to0. Como Q_A era 1, Q_B toggle 1\to0. E como Q_BQ_A antes do pulso era 1\cdot1=1, Q_C também toggle 0\to1. Resultado do carry: \,100.
  • Resultado: \,Q_C=1,\\ Q_B=0,\\ Q_A=0. Posição decimal \,4.

Passo 11

Pulso 5 — modo Down ( S=0).
  • Agora começamos a decrementar: decrementa \,100 \to 011.
  • Raciocínio: No modo Down, o LSB \,Q_A também sempre toggle (pois J_A=K_A=1). Quando decrementando um número em binário, se LSB antes do pulso era 0, o próximo será 1 e ocorre borrow que faz toggle nos bits superiores quando necessário. Mais diretamente: 100_{(2)}-1=011_{(2)}.
    • Antes do pulso: Q_A=0, então em Down isso causa toggle em Q_B (porque em Down Q_B toggla se \bar{Q_A}=1, ou seja Q_A=0).
    • E como ambos os bits inferiores antes do pulso eram Q_B=0 e Q_A=0, isso fará com que Q_C toggla também (em Down detectamos \bar{Q_B}\bar{Q_A}=1).
  • Resultado: \,Q_C=0,\\ Q_B=1,\\ Q_A=1. Posição decimal \,3.

Passo 12

Pulso 6 — modo Down.
  • Decrementa \,011 \to 010.
  • Raciocínio: Q_A toggle 1\to0. Em Down, Q_B toggla quando Q_A=0 antes do pulso — aqui antes Q_A=1 (pois o estado atual é o que acabou de ser obtido no passo anterior), então Q_B não toggla agora. Q_C não toggla.
  • Resultado: \,Q_C=0,\\ Q_B=1,\\ Q_A=0. Posição decimal \,2.

Passo 13

Pulso 7 — modo Up (voltou a avançar).
  • Incrementa \,010 \to 011.
  • Raciocínio: Em Up, Q_A toggle 0\to1. Como Q_A era 0, Q_B não toggle agora. Q_C não.
  • Resultado: \,Q_C=0,\\ Q_B=1,\\ Q_A=1. Posição decimal \,3.

Passo 14

Pulso 8 — modo Up.
  • Incrementa \,011 \to 100.
  • Raciocínio: Igual ao passo 10: Q_A toggle 1\to0; Q_B toggle 1\to0; e Q_C toggle 0\to1 porque Q_BQ_A antes do pulso era 1\cdot1.
  • Resultado final: \,Q_C=1,\\ Q_B=0,\\ Q_A=0. Posição decimal \,4.

Resposta

(a)(i) A diferença entre contagem crescente e decrescente está nas condições que fazem cada flip-flop JK togglar: no modo Up as portas testam padrões de \,Q (por exemplo Q_A=1, Q_BQ_A=1) enquanto no modo Down usam os complementos \,\bar{Q} (por exemplo \bar{Q_A}=1, \bar{Q_B}\bar{Q_A}=1); as saídas \,Q e \bar{Q} fornecem, respectivamente, o valor do bit e seu complemento para essas detecções.
(a)(ii) O sinal de controle é \,S (por exemplo \,S=1 para Up e \,S=0 para Down); ele atua como seletor nas portas lógicas que geram J e K, escolhendo entre as condições “bits inferiores = 1” (modo Up) ou “bits inferiores = 0” (modo Down).
(a)(iii) São necessárias portas lógicas adicionais (AND, OR, inversores / multiplexadores) para detectar padrões em vários bits inferiores e multiplexar entre as condições Up/Down, produzindo os sinais J e K corretos para cada flip-flop.
(b) Estado final: \,Q_CQ_BQ_A = 100, posição decimal \,4.

Exercícios relacionados