Utilizando a metodologia RTL, projete um sistema que funciona da seguinte maneira:
Após realizar a comparação dos
valores, o sistema deve apresentar em uma saída [Sout] o valor da soma acumulada
(dos valores que atenderam à condição Rin >
), 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.
Após realizar a comparação dos
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:- Compara cada
Rin
com um limiar fixoB
. - Se
Rin > B
, acumula esseRin
numa somaS
e conta emCnt
. - 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 emRin > B
).CntPar
(contagem de valores pares).
Registradores internos:
reg [7:0] i;
// contador de ciclos de 1 a Nreg [15:0] S;
reg [7:0] Cnt, CntPar;
Passo 3
Datapath (blocos de dados):
- Comparador: gera um sinal
gt
= 1 se$Rin > B$
. - Somador condicional: quando
gt==1
, fazS_next = S + Rin
. - Detector de par: se
Rin[0]==0
entãoeven = 1
. - Contadores:
Cnt_next = Cnt + gt
CntPar_next = CntPar + even
- Ciclo principal: um contador
i
que incrementa atéN
, gerando um sinaldone
quandoi == N
.
Explicando a teoria na prática:
- O comparador é só uma lógica que avalia bit a bit de
Rin
vsB
. - 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:
Estados principais:
- IDLE: espera
reset
desativar ou algum sinal de “start”. Ao entrar, zerai, S, Cnt, CntPar
. - PROC: em cada subida de
clk
, lêRin
, dispara o comparador e detector de par, atualizaS, Cnt, CntPar
conforme suas regras, incrementai
. - DONE: quando
i == N
, mantém os valores finais emS, 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:
Onde
se
, senão
.
Resposta
O sistema RTL consiste em:
- Datapath com registradores
S
,Cnt
,CntPar
,i
; comparador (Rin>B
); somador; detector de par (Rin[0]==0
) e incrementadores condicional. - FSM com 3 estados (IDLE, PROC, DONE) que inicializa (zera os regs), processa N valores atualizando
, , conforme: -
-
-
e, quando o contador de ciclosalcança , vai para DONE e mantém os resultados nas saídas.
-