Problema II – 2 puntos

Queremos implementar un filtro paso bajo con un diezmado por 128.

El sistema está compuesto por un filtro CIC y un filtro CFIR compensatorio.
Los dos bloques están codificados en las dos funciones C siguientes.
data_f CIC (data_t x) ; data_f CFIR (data_t x) ;
Las dos funciones calculan un dato de salida por cada llamada.
Modificar la función C siguiente para que implemente el diezmado.
La entrada del CFIR tendrá un diezmado por 64.

data_f DDC (data_t x) {

data_f tmp ;

tmp = CIC(x) ;
tmp = CFIR(tmp);

return(tmp);
}

Podemos cambiar la interface si fuese necesario.

Tener en cuenta que hay que llamar a la función DDC para cada dato de entrada pero
solo uno de cada 128 datos de salida tiene sentido.
Problema II – 1 punto cada uno.

Para los dos casos calcular el throughtput máximo en ciclos de reloj, indicar el
número de multiplicadores y el ancho de banda necesario en bits por ciclo.
Indicar las directrices necesarias para alcanzar el throughtput máximo.
#include "fir.h"
#define N 100
void fir ( data_t *y, coef_t c[N], data_t x)
{
static data_t shift_reg[N];
acc_t acc;
data_t data;
int i;
acc=0;
Shift_Accum_Loop: for (i=N-1;i>=0;i--) {

if (i==0) {
shift_reg[0]=x;
data = x;
} else {
shift_reg[i]=shift_reg[i-1];
data = shift_reg[i];
}
acc+=data*c[i];
}
*y=acc;
}
#include "fir.h"
#define N 100
void fir ( data_t *y, data_t x)
{
static data_t shift_reg[N];
constant static coef_t c[N] = #include “coeff.h” ;
acc_t acc;
data_t data;
int i;
acc=0;
Shift_Accum_Loop: for (i=N-1;i>=0;i--) {
if (i==0) {
shift_reg[0]=x;
data = x;
} else {
shift_reg[i]=shift_reg[i-1];
data = shift_reg[i];
}
acc+=data*c[i];
}
*y=acc;
}

Directrices simplificadas (no hay que utilizarlas forzosamente todas):

set_directive_pipeline -II <integer> <location>

set_directive_unroll <location>
set_directive_array_partition <array>
set_directive_interface -mode ap_memory <array>
PROBLEMA 2: 3 Puntos

Queremos implementar el filtro IIR siguiente:

Y(k) = (X(k)+ 3*X(k-1) + 2* X(k-2)) *G + A1 * Y(k-1);

Los datos del sistema son:

G: 16 bits, escala 2**-25
A1:16 bits, escala 2**-15
X:12 bits, escala 2**0

La ganancia máxima del filtro es de 2.

Se pide:
1) Calcular el número de bits de Y y la escala para que se utilicen todos los bits de
la entra en el cálculo de la salida.
2) Codificar en VHDL sintetizable el filtro con una frecuencia de muestreo igual a
la mitad de la frecuencia de reloj.
Problema III 3 puntos.

La figura 1 muestra el diagrama de bloques de un oscilador digital. Los

triángulos modelan etapas de ganancia, los círculos sumadores, los bloques
1 z unidades de retardo y la función sgn(u) calcula el signo de u: su salida
será 1 si su entrada es positiva o nula y 0 si es negativa.
Y
sgn(u)

B3 B1

GB3 GB1

UD2 1 UD2_REG UD1 1 UD1_REG UD0 1

SAL
z z z UD0_REG
GA3 GA2

A3 A2

FIGURA 1.
La frecuencia de muestreo es la cuarta parte de la frecuencia de reloj.
La Tabla 1 muestra el número de bits requerido para codificar los
coeficientes y las unidades de retardo. Los coeficientes B1,B3,A2,A3 están
codificados en complemento a dos con escala de 2**-12.
El valor numérico máximo alcanzable en los registro es [-0.33,0.33)
B1 B3 A2 A3 UD0_REG UD1_REG UD2_REG
3 bits 5 bits 12 bits 11 bits 20 bits 20 bits 20 bits
TABLA 1 Número de bits necesarios para codificar los coeficientes y las
unidades de retardo

Codificar en VHDL sintetizable el circuito utilizando procesos diferentes

para la parte secuencial y combinatoria.
Problema II – 3 puntos

Queremos diseñar un circuito que nos indique en qué posición de una

palabra de 16 bits esta la primera pareja de ceros y de unos. En caso de que
no se encuentre al menos una pareja de cada, las dos salidas valdrán 0. Los
datos llegan de forma síncrona con el reloj. Cada vez que la entrada LOAD
vale 1, la entrada DATO tiene un nuevo bit. Después de haber leído los 16
bits, el circuito actualizara las nuevas salidas en el ciclo de reloj siguiente y
volverá a procesar el nuevo dato.

Entradas: DATO,LOAD,RESET,CLK
Salidas : unos(3 downto 0) , ceros(3 downto 0).

Ejemplo: DATO = 0110 0000 0101 1101  primer bit

ceros = 7 unos = 2

Se pide:
Nombre y número de bits de los flipflop utilizados.
Codificar en VHDL sintetizable el circuito utilizando procesos diferentes
para la parte secuencial y combinatoria. Se recomienda leer primero todos
los datos y procesar la información cuando se disponga de todos los datos en
un ciclo.
Tenemos un circuito que recibe una serie de palabras en modo serie.por 4
entradas Los datos llegan de forma síncrona con el reloj por la entrada
DATO. Cada vez que la entrada LOAD vale 1, la entrada DATO(3:0) tiene
4 nuevos bits validos. La entrada FIN valdrá ‘1’ cuando se reciba la última
palabra, el circuito actualizara la nueva salida en el ciclo de reloj siguiente
y volverá a procesar la nueva serie.
Los bits recibidos representan un número positivo codificado en BCD. El
primer digito recibido es el LSB. Queremos codificar el número recibido en
binario con una longitud de 128 bits, no nos preocuparemos de un posible
overflow.
Entradas : DATO(3 downto 0), LOAD, FIN, RESET, CLK
Salidas : BINARIO(127 downto 0)
Codificar en VHDL sintetizable el circuito utilizando procesos diferentes
para la parte secuencial y combinatoria.
Indicar nombre y número de bits de los flipflop utilizados.