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
) com um valor de referência recebido pela entrada
, 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
.
Depois de realizado o carregamento dos dados, o sistema deve comparar cada valor armazenado no registrador (iniciando pelo valor de índice
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:
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):
- Registrador de dados R: memória de N palavras (cada palavra largura W bits).
- Contador de índice “idx” que começa em N-1 e faz idx ← idx – 1 a cada clock.
- Mux/Leitura: usa o valor idx para endereçar R[idx] e enviar para o comparador.
- Comparador: recebe R[idx] e B, gera sinal “gt” = 1 se R[idx] > B, senão 0.
- 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)
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.
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
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.
• 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:
- Clock 1 (IDLE→CHECK): idx=N-1, S=0; ativa read_R e cmp_en.
- Clock 2 (CHECK→UPDATE): comparador já deu gt;
- Clock 3 (UPDATE→DEC): se gt=1, S←S+R[N-1]; se gt=0, S mantém;
- Clock 4 (DEC→CHECK): idx←N-2;
- Repete CHECK/UPDATE/DEC até idx=0;
- 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:
onde
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:
• 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: