Utilizando a metodologia RTL, projete um sistema que funciona da seguinte maneira:
Depois de realizado o carregamento dos dados, o sistema deve comparar cada valor armazenado no registrador (iniciando pelo valor de índice N-1 ) com um valor de referência recebido pela entrada [B], sendo uma comparação realizada a cada pulso de clock. Para cada valor do registrador que for maior que a referência ([Rin]>[B]), deve-se incluí-lo em uma soma acumulada identificada como S.

Passo 1

Beleza, olha só o que a questão pede: a gente tem um conjunto de dados carregados num registrador de profundidade N (ou seja, um array interno R[0…N-1]). Depois que tudo tá carregado, a cada pulso de clock a máquina pega o valor em R[indice], começando em indice = N-1, compara com uma entrada de referência B e, se R[indice] for maior que B, acumula esse R[indice] numa soma S. Quando indice chega em 0, acabou, a gente tem S = soma de todos os R[i] que eram maiores que B.
Conteúdo: projeto RTL (Register-Transfer Level), ou seja, descrição de datapath (registradores, comparador, somador, contador) + controle sequencial (FSM). Vamos precisar entender:
  • Como funciona um contador/decrementador de índice;
  • Como ler um valor de registrador por vez;
  • Como usar um comparador e, baseado no resultado, controlar um somador/acumulador;
  • Como fazer uma máquina de estados simples (FSM) para coordenar tudo.

Passo 2

Datapath (blocos principais):
  1. Registrador de dados R: memória de N palavras (cada palavra largura W bits).
  2. Contador de índice “idx” que começa em N-1 e faz idx ← idx – 1 a cada clock.
  3. Mux/Leitura: usa o valor idx para endereçar R[idx] e enviar para o comparador.
  4. Comparador: recebe R[idx] e B, gera sinal “gt” = 1 se R[idx] > B, senão 0.
  5. Acumulador S: registrador que inicia em zero e, quando “gt” = 1, recebe S ← S + R[idx].
Visualizando:
R[idx] ──▶|>B|──(gt)?──▶ Mux de soma ──▶ + ──▶ S(next)
▲ ▲
│ │
B S(current)
E tem o contador idx que alimenta R e decremente.

Passo 3

Control unit (FSM simples):
Estados:
• IDLE: espera sinal “start”. S ← 0, idx ← N-1.
• CHECK: compara R[idx] com B;
• UPDATE: se gt=1 faz load_acum=1 (S←S+R[idx]), senão load_acum=0;
• DEC: faz idx←idx–1; se idx>0 volta pra CHECK, senão vai pra DONE;
• DONE: sinal “ready” = 1, mantém S estável até novo start.
Transição típica por clock:
IDLE → CHECK (on start)
CHECK → UPDATE
UPDATE → DEC
DEC → CHECK ou DONE
Sinais de controle:
• read_R = 1 em CHECK para capturar R[idx];
• cmp_en = 1 em CHECK para gerar gt;
• add_en = gt em UPDATE para carregar o somador;
• dec_en = 1 em DEC para decrementar o idx;
• ready = 1 em DONE.

Passo 4

Operação por pulso de clock:
  1. Clock 1 (IDLE→CHECK): idx=N-1, S=0; ativa read_R e cmp_en.
  2. Clock 2 (CHECK→UPDATE): comparador já deu gt;
  3. Clock 3 (UPDATE→DEC): se gt=1, S←S+R[N-1]; se gt=0, S mantém;
  4. Clock 4 (DEC→CHECK): idx←N-2;
  5. Repete CHECK/UPDATE/DEC até idx=0;
  6. Quando o passo DEC encontra idx=0, próxima vai pra DONE e levanta ready com S final.

Passo 5

Expressão final da soma:
S = sumi=0^N-1 R[i];cdot;[R[i] > B]
onde [R[i]>B]=1,&se R[i]>B;0,&caso contrárioá

Resposta

O circuito RTL consiste em:
• Datapath: registrador R[N], contador idx, comparador, somador/ acumulador S.
• FSM com estados IDLE, CHECK, UPDATE, DEC, DONE.
Funcionamento: ao start, zera S e seta idx=N-1; a cada 3 clocks lê R[idx], compara com B e, se R[idx]>B, faz S←S+R[idx]; então decrementa idx e repete até idx=0; em DONE sai o valor S final.
Em fórmula resumida:
S = sumi=0^N-1 R[i]times1R[i]>B

Exercícios relacionados