Utilizando a metodologia RTL, projete um sistema que funciona da seguinte maneira:
Após realizar a comparação dos N valores, o sistema deve apresentar em uma saída [Sout] o valor da soma acumulada S (dos valores que atenderam à condição Rin > B ), e em outra saída Cnt a contagem de valores que atenderam à condição Rin >B. Além disso, deve apresentar em uma saida CntPar o número de valores que são pares.

Passo 1

Beleza, aqui o enunciado tá pedindo pra gente projetar – usando a metodologia RTL – um circuito que, depois de ler N valores de entrada (Rin), faz três coisas:
  1. Compara cada Rin com um limiar fixo B.
  2. Se Rin > B, acumula esse Rin numa soma S e conta em Cnt.
  3. Conta quantos dos N valores são pares e guarda isso em CntPar.
Conteúdo da matéria: lógica sequencial (registradores, comparadores, contador, FSM) e datapath + control path. Para resolver vamos precisar de:
  • Registradores (para Rin, B, índices, S, Cnt, CntPar)
  • Comparador (Rin > B)
  • Somador (S + Rin)
  • Módulo para decidir se é par (Rin mod 2 == 0)
  • Contadores (para N ciclos e para Cnt, CntPar)
  • Uma FSM simples pra controlar as etapas de leitura/computação/finalização.

Passo 2

Definindo sinais e registradores:
  • Entradas:
    • clk, reset síncronos.
    • Rin (por exemplo, 8 bits) – o dado que chega a cada ciclo.
    • B (8 bits) – o valor de comparação (constante ou carregado uma vez).
    • N (por exemplo, 8 bits) – número total de valores que vamos processar.
  • Saídas:
    • S (soma acumulada, precisa ter largura suficiente, digamos 16 bits).
    • Cnt (contagem de valores que passaram em Rin > B).
    • CntPar (contagem de valores pares).
Registradores internos:
  • reg [7:0] i; // contador de ciclos de 1 a N
  • reg [15:0] S;
  • reg [7:0] Cnt, CntPar;

Passo 3

Datapath (blocos de dados):
  1. Comparador: gera um sinal gt = 1 se $Rin > B$.
  2. Somador condicional: quando gt==1, faz S_next = S + Rin.
  3. Detector de par: se Rin[0]==0 então even = 1.
  4. Contadores:
    • Cnt_next = Cnt + gt
    • CntPar_next = CntPar + even
  5. Ciclo principal: um contador i que incrementa até N, gerando um sinal done quando i == N.
Explicando a teoria na prática:
  • O comparador é só uma lógica que avalia bit a bit de Rin vs B.
  • O somador é um bloco que faz soma binária pura.
  • Para saber se um número é par, usamos que os números pares têm o bit menos significativo igual a zero, ou seja, Rin mod 2 == 0 ⇔ Rin[0] == 0.
  • Os registradores guardam o estado (valor de S, Cnt, i) entre ciclos de relógio.

Passo 4

Control Path (FSM):
Estados principais:
  • IDLE: espera reset desativar ou algum sinal de “start”. Ao entrar, zera i, S, Cnt, CntPar.
  • PROC: em cada subida de clk, lê Rin, dispara o comparador e detector de par, atualiza S, Cnt, CntPar conforme suas regras, incrementa i.
  • DONE: quando i == N, mantém os valores finais em S, Cnt, CntPar e pode sinalizar “fim” para quem for usar esse módulo.
Transição formal (em pseudocódigo):
if reset==1:
  state <= IDLE
else case(state)
  IDLE:
    i <= 0; S<=0; Cnt<=0; CntPar<=0;
    if start==1: state<=PROC;
  PROC:
    // roda um ciclo de cálculo:
    if Rin > B: S<=S+Rin; Cnt<=Cnt+1;
    if Rin[0]==0: CntPar<=CntPar+1;
    i<=i+1;
    if i+1 == N: state<=DONE;
  DONE:
    // fica aqui até reset; S, Cnt, CntPar estacionários

Passo 5

Vamos detalhar a equação de atualização de cada registrador:
  • Snext = S + (> ? Rin : 0)
  • Cntnext = Cnt + (> ? 1 : 0)
  • CntParnext = CntPar + (,Rin[0]==0,?1:0)
Onde > = 1 se Rin > B, senão 0.

Resposta

O sistema RTL consiste em:
  1. Datapath com registradores S, Cnt, CntPar, i; comparador (Rin>B); somador; detector de par (Rin[0]==0) e incrementadores condicional.
  2. FSM com 3 estados (IDLE, PROC, DONE) que inicializa (zera os regs), processa N valores atualizando S, Cnt, CntPar conforme:
    • S S + (Rin>B)times Rin
    • Cnt Cnt + (Rin>B)
    • CntPar CntPar + [Rin bmod 2 = 0]
      e, quando o contador de ciclos i alcança N, vai para DONE e mantém os resultados nas saídas.

Exercícios relacionados