Estudio Filtro Iir

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.
75
ESTUDIO DEL FILTRO IIR

EN PRESENCIA DE S.E.U.
4.1. INTRODUCCIN
En este apartado vamos a hacer un estudio de un filtro IIR en
particular, en concreto un filtro IIR paso de bajo con los siguientes
parmetros:
- Frecuencia de paso: fp = 5 Khz.,

- Frecuencia de corte: fs = 7 Khz.,
- Atenuacin en la banda de paso: rp = 1 dB,
- Atenuacin en la banda de rechazo: rs = 25 dB,
Jos Manuel Marn de la Rosa
76
- Frecuencia de muestreo: fsim = 48 Khz.,
Este filtro ser el que tendremos que implementar en la FPGA para

despus, como hemos realizado con el FIR, estudiar su sensibilidad en
presencia de SEU (Single Event Upset). Para implementarlo tendremos que
saber su orden y sus coeficientes, ya que un filtro IIR es parecido a un FIR
pero se diferencia en que el IIR tiene una etapa de realimentacin de la
salida que no tenia el IIR (Ver Fundamentos tericos).
Una vez que sepamos el orden del filtro (que por regla general, para
unas especificaciones parecidas como son las del FIR que usamos en el
captulo anterior y las de el IIR que vamos a implementar, es siempre de un
orden mucho menor que el del FIR) y los coeficientes, lo que tendremos
que hacer es implementarlo en un lenguaje de descripcin hardware
(VHDL), tal y como hicimos con el FIR. Al igual que en el FIR, en el IIR,
los retrasos los implementaremos con flip-flops.
Cuando tengamos implementado el filtro en la FPGA el siguiente

paso ser comprobar que efectivamente funciona como debe de funcionar y
que filtra las frecuencias oportunas (comprobacin similar a la que hicimos
en el FIR), o sea comprobar si el filtro real implementado en la FPGA,
genera las mismas salidas que el filtro terico implementado en
MATLAB ante el mismo estmulo de entrada.
Llegados a este momento, ya tenemos nuestro filtro IIR

implementado en la FPGA, ahora es cuando haremos un estudio exhaustivo
sobre l realizndole diversas pruebas para ver como de sensible es en
presencia de SEU.
77
Todos estos pasos se irn describiendo en los siguientes apartados.
4.2. CARACTERIZACIN DEL FILTRO FIR EN MATLAB

Una vez que sabemos las especificaciones del filtro, el primer paso
que debemos de dar ser saber cual es el orden de dicho filtro y cuales son
sus coeficientes. Para esto utilizamos MATLAB. Vamos a usar en este caso
la aproximacin elptica, y para sacar el orden y los coeficientes usamos la
siguiente funcin de MATLAB:
% Funcion que genera un filtro elptico paso bajo, con

frecuencia de paso fp, frecuencia de la banda de rechazo
fs, atenuacin
% de la banda de de paso rp,
rechazo rs
rp=1;
rs=25;
fp=5000;
fs=7000;
fsim=48000;
wp=2*fp/fsim;
ws=2*fs/fsim;
[N,Wn]=ellipord (wp,ws,rp,rs);
atenuacin de la bada de
78
[b,a]=ellip(N,rp,rs,Wn);
f=1:100:20000;
H=freqz(b,a,f,fsim);
plot(f,abs(H));
Con esta funcin obtenemos el orden del filtro (N) y los coeficientes
(a y b). El orden sale 4 y los coeficientes son:
Coeficientes a
Valor
a1
a2
-2.9457
a3
3.6851
a4
-2.2205
a5
0.5502
Tabla 3: Coeficientes a
Coeficientes b
Valor
b0
0.0695
b1
-0.1308
b2
0.1842
b3
-0.1308
b4
0.0695
Tabla 4: coeficientes b
En Realidad, el coeficiente a1 del filtro no es 0, sino que es 1. Lo que

pasa es que nosotros lo haremos 0, ya que el 1 se le suma automticamente
79
al estar el bloque de los coeficientes a en el bucle de realimentacin (ver

figura 21).
Estos son los coeficientes que tendremos que digitalizar para poder
implementar el filtro en la FPGA.
Y el filtro que se obtiene es el siguiente:
Figura 20: filtro IIR implementado
80
Para comprobar que esto funciona bien, hacemos uso de la

herramienta SIMULINK de MATLAB y hacemos el siguiente montaje:
Figura 21: Montaje simulink filtro IIR
En la figura 21 lo que hemos realizado ha sido meter 2 bloques

discrete filter en el que le hemos pasado como parmetros, dentro de las
variables b(z) y a1(z) los coeficientes de la tabla 4 y la tabla 3
respectivamente.
Para probarlo, le hemos introducido 2 seales de entrada, en concreto

2 senos, uno a una frecuencia dentro de la banda de paso (4 khz) y otro
superior a la banda de paso (5.5 Khz.), y comprobamos que a la salida se
filtra y solo tenemos el seno de 4 Khz. Si simulamos, lo que se obtiene es
lo siguiente:
81
Figura 22: Salida filtro IIR
Como se observa en la figura 22, en el osciloscopio se mete tanto la

entrada como la salida, para poder visualizar las dos seales a la vez. La
entrada (ambas senoides sumadas) es la seal amarilla, y la seal de salida,
la filtrada (que debe de ser solo la sinusoidal de 4 Khz.) es la seal rosa. Se
ve claramente como el filtro funciona correctamente, y como a la salida
tenemos solo la seal de 4 Khz. (discretizada claro est al tratarse de un
filtro discreto).
Si hacemos un anlisis espectral de nuestro sistema, poniendo a la

salida de nuestro filtro IIR un analizador de espectro obtenemos la imagen
de la figura 23, en la que podemos ver la seal de salida en el tiempo, la
densidad espectral de potenica y la fase. Como caba esperar tenemos 2
sampling, una centrada a la frecuencia de 4 Khz. de gran densidad de
potencia, y otra pequea sampling de frecuencia 5.5 Khz. con muy baja
densidad de potencia a la salida, ya que es filtrada casi en su totalidad.
Figura 23: Anlisis espectral de la salida del filtro
82
83
4.3. IMPLEMENTACIN DEL FILTRO EN LA FPGA

Una vez que ya tenemos nuestro filtro perfectamente caracterizado y
definido ( El filtro es de orden 4, y sabemos todos sus coeficientes), el
siguiente paso ser implementarlo en una FPGA, y para ello habr que
implementar la estructura del filtro IIR (Figura 21) en un lenguaje de
descripcin hardware, que en nuestro caso ser el lenguaje VHDL.
La estructura que tenemos que implementar en hardware es una

estructura como la que sigue:
Figura 24: Estructura directa I filtro IIR
Que como vimos en los fundamentos tericos, se trata de la

estructura directa I.
Para nuestro diseo, hemos decidido, que la seal digital que entra en
el filtro (X(n)) provenga de digitalizar la seal analgica con 18 bits, as
que las muestras de la seal de entrada estarn codificadas con 18 bits, ya
que as logramos tener una buena precisin. Y los coeficientes de nuestro
filtro lo vamos a codificar con 9 bits y vamos a usar 1 bit para codificar la
parte entera de los coeficientes y 8 para la parte decimal.
84
Lo primero que tenemos que realizar es codificar los coeficientes de

las tablas 3 y 4 en 9 bits ( 1 para la parte entera y 8 para la parte decimal) .
Si cuantizamos, tendremos que multiplicarlos por 256, eso es lo q vamos a
hacer con los coeficientes b. Con los a, para que no salgan muy grandes y
no lo podamos codificar, lo multiplicaremos por 64, y sabemos que despus
la salida que se obtenga hay que multiplicarla por 4 para que todo salga
correcto (esta multiplicacin se har en hardware, la codificaremos en
VHDL).
As que haremos eso, multiplicaremos todos los coeficientes por esos

valores y redondearemos al entero ms cercano obteniendo la siguiente
tabla:
Coeficiente
Valor
Codificacin con 9
bits en CA2
a1
000000000
a2
-189
101000011
a3
236
011101100
a4
-142
101110010
a5
35
000100011
Tabla 5: Coeficientes a Codificados en CA2
85
Coeficiente
Valor
Codificacin con 9
bits en CA2
b0
18
000010010
b1
-33
111011111
b2
47
000101111
b3
-33
111011111
b4
18
000010010
Tabla 6: coeficientes b Codificados en CA2
Para implementar en hardware la estructura de la figura 21

actuaremos como en el caso del filtro FIR, es decir, modelando los retrasos
con flip-flops, a los que les entrarn un vector de 18 bits y saldrn otro
vector de 18 bits retrasados un ciclo. La salida de cada biestable es
multiplicada por el coeficiente correspondiente, para implementar dicha
multiplicacin usaremos multiplicadores de 18X9 bits y el resultado se ir
almacenando en un vector de 27 bits para evitar el overflow. Luego se hace
la suma de todas las multiplicaciones de la seal de entrada por los
coeficientes b, y le restamos la suma de todas las multiplicaciones de la
seal de salida por los coeficientes a, para hacer la realimentacin de la
salida al tratarse de un filtro IIR. Y por ltimo, el resultado se mete en un
vector de salida de 18 bits. Esto, a grosso modo, es lo que se ha realizado
para implementar el filtro en la FPGA. El cdigo en VHDL, queda de la
siguiente manera:
86
---------------------------------------------------------------------------------------------------------------------- Filtro IIR:

--
Seal digital de entrada de 18 bits
--
Coeficientes de 9 Bits
--
Filtro paso de baja tipo Butterworth, con frecuencia
de corte de 5 Khz.
---------------------------------------------------------------------------------------------------------------------
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
-- Filtro iir
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use work.fir_coef.all;
entity iir is
port (clk,reset,load: in std_logic;

data_in: in std_logic_vector(17 downto 0);
data_out: out std_logic_vector(17 downto 0);
ultima_etapa: out std_logic_vector(17 downto 0));
end iir;
architecture a_iir of iir is
signal data_outi: std_logic_vector(17 downto 0);

signal data_outb, data_outa: signed (17 downto 0);
signal data_outbv, data_outav: std_logic_vector(17
downto 0);
component fir
Generic (es_a: integer:=0);
port (clk,reset,load: in std_logic;

data_in: in std_logic_vector(17 downto 0);
data_out: out std_logic_vector(17 downto 0);
ultima_etapa: out std_logic_vector(17 downto 0));
end component;
begin
fir_a: fir
generic map (es_a=>1)
port map (clk=>clk, reset=>reset, load=>load,
data_in=>data_outi, data_out=>data_outav);
data_outa <= signed (data_outav);
fir_b: fir
generic map (es_a=>0)
port map (clk=>clk, reset=>reset, load=>load,
data_in=>data_in, data_out=>data_outbv);
data_outb <= signed (data_outbv);
firstruct: process (data_outa,data_outb)

variable idata_tmp: signed (19 downto 0);
variable data_tmp: signed (17 downto 0);
87
88
begin
idata_tmp :=
(data_outb(17)&data_outb(17)&data_outb(17 downto 0)) (data_outa&"00") ;
if idata_tmp(19 downto 18) = "01"
then --
significa que desborda por arriba

data_tmp:=(17=>'0',others=>'1');
elsif idata_tmp(19 downto 18) = "10" then

-significa que desborda por abajo
data_tmp:=(17=>'1',others=>'0');
else
data_tmp:=idata_tmp(17 downto 0);
end if;
data_outi <= std_logic_vector (data_tmp);

end process firstruct;
data_out <= data_outi;
ultima_etapa <= (others =>'0');

end a_iir;
89
Este cdigo es el Top del filtro IIR, este cdigo, junto con la
descripcin de los componentes, se adjuntan al final de la documentacin
en el apartado Anexos.
Una vez que ya tenemos implementado nuestro filtro FIR en la

FPGA, lo que tenemos que hacer es probar si realmente funciona bien, para
ello, como hicimos en el caso del FIR, lo que hicimos es compararlo con el
filtro terico que caracterizamos en MATLAB, siguiendo los mismos
pasos que para el FIR, es decir meterle a los dos la misma entrada y ver las
salidas, sabiendo que tenemos que obtener salidas parecidas.
Esta prueba la realizamos en el laboratorio y observamos un

resultado positivo. (omitiremos los ficheros obtenidos ya que son parecidos
a los que se obtuvieron en el caso del filtro FIR). Como en el caso anterior,
los pequeos errores que se tienen son errores difciles de evitar debido a
los redondeos y truncamientos que se hacen en el filtro digital para obtener
la salida.
90
4.4. ESTUDIO EXHAUSTIVO DEL FILTRO IIR. PRUEBAS

REALIZADAS
En este punto estudiaremos como se comporta este filtro IIR que
hemos implementando en la FPGA en presencia de SEU.
El estudio que vamos a hacer del filtro ser un estudio similar al que
hicimos con el filtro FIR, o sea, introduciremos fallos en determinadas
partes de nuestro filtro con ayuda de la misma herramienta que usamos
para el estudio del FIR diseada en el proyecto FT-UNSHADES a la
cual ya hicimos referencia en el capitulo anterior, y cuya documentacin,
como ya dijimos, la introducimos en el capitulo Anexos, y veremos la
respuesta del filtro ante estos fallos, viendo si se produce error o no en la
salida del filtro, para as, hacer un mapa de nuestro filtro viendo donde si
se produce fallo en ese sitio es ms grave para nuestro sistema, ya que
como veremos, habr bits en los cuales, aunque se introduzca un fallo, la
salida no lo notar y ser igual que si no se hubiese producido dicho fallo.
Mientras que habr otros bits, en los cuales si se tiene un fallo en ese bit,
ser crtico para nuestro filtro, ya que un fallo en ese bit puede que siempre
produzca un fallo en la salida. As, como hicimos para el FIR, sabremos
que registros y que bits dentro de dichos registros son ms interesantes
de proteger para un mejor funcionamiento de nuestro sistema.
En este apartado, como ya hemos dicho, el estudio va a ser muy

similar al que hicimos para el FIR, pero vamos a variar un poco nuestro
modos operandi ya que en vez de ir creando distintas pruebas
redundando bits diferentes (eso conllevaba crear un cdigo nuevo cada vez,
compilarlo y cargarlo en la FPGA) lo que vamos a hacer es que slo vamos
91
a atacar los bits que no queramos redundar, sin tocar los que queramos
darle triple redundancia modular, o sea, que vamos a utilizar un nico
diseo desprotegido y slo vamos a introducir errores en los bits de los
registros que no queramos redundar en esa prueba, ya que introducir un
error en un bit redundado no sirve para nada, ya que sabemos que al tener
triple redundancia modular ese fallo no se ver reflejado en un error a la
salida de nuestro sistema. Y as podremos ver tambin, al igual que en el
caso anterior, que registros y bits son ms importantes de redundar
ahorrando una gran cantidad de tiempo en pruebas de laboratorio.
4.4.1. PRUEBAS REALIZADAS

PRUEBA 0:
La primera prueba que realizamos fue ver como
funcionaba nuestro filtro sin proteccin, o sea, sin redundar nada, en

presencia de SEU, y los resultados que se obtuvieron, nos dejaron ver que,
como al igual que el FIR, los bits ms sensibles son los bits ms
significativos, ya que un fallo en uno de ellos producen casi
automticamente un error en la salida. O sea, ya sabemos que estos son los
bits ms importantes a la hora de redundar. (Nota: esta prueba fue
orientativa, por esa razn no guardamos datos ni documentos, de las
sucesivas si tenemos toda la informacin)
92
PRUEBA 1: La siguiente prueba que realizamos fue la siguiente:
Registro a_0: Simple

Registro a_1: Solo redundamos el bit ms significativo, el MSB
Registro a_2: Redundamos los 2 bits MSB
Registro a_3: Redundamos los 3 bits MSB
Registro b_0: Simple
Registro b_1: Redundamos el MSB
Registro b_2: Redundamos los 2 bits MSB
Para realizar esta prueba, no tuvimos que crear de nuevo el fichero

VHDL compilarlo y pasarlo a la FPGA, lo que hicimos, para acelerar el
proceso, fue solamente atacar el diseo desprotegido, pero solamente los
bits que no se redundan, ya que como dijimos antes, atacar un bit
redundado no sirve de nada, porque sabemos que un fallo en el, no dar
error en la salida.
Pues haciendo esta prueba, los resultados que obtuvimos fueron los
siguientes:
- Flip-flops bajo ataque: 198

- Tasa de error: 8.26 %
- Errores se producen 2.9 ciclos de media despus de introducirse
el error, en un rango de 1 a 13 ciclos.
93
Como se puede observar, redundando muy pocos bits, ya se tiene una

tasa de error relativamente baja. Si observamos el fichero de salida
referente a esta prueba 1 (adjunto en CD), se puede observar como casi
todos los errores se tienen en los bits del 10 al 17 de cada registro, as que
redundando estos bits casi con total seguridad se puede obtener una tasa de
fallos muy reducida.
PRUEBA 2: En esta prueba vamos a redundar los bits del 10 al 17 de cada

registros, o sea, los 8 bits ms significativos tanto de los registros de a,
como los registros de b.
Registro a_0: Redundamos los 8 bits ms significativos

Registro b_0: Redundamos los 8 bits ms significativos
Para realizar esta prueba, lo nico que tenemos que hacer es dejar de
atacar a los 8 MSB de cada registro, o sea, vamos a atacar a los 10 bits
menos significativos de todos los registros.
94
Realizando esta prueba, los resultados que obtuvimos fueron los

siguientes:

el error, con un rango de 1 a 10 ciclos.
Como vaticinamos al ver los resultados de la prueba anterior,

redundando los 8 MSB de cada registro, la tasa de error que se tiene al estar
expuesto nuestro diseo a los SEU es casi nula, aunque claro est, y que no
se nos olvide, en esta prueba hemos redundado casi la mitad del sistema.
PRUEBA 3: Para demostrar que realmente los MSB son los bits ms
sensible de los registros, vamos a realizar ahora la prueba inversa a la 2, o
sea, redundar los 10 LSB:
Registro a_0: Redundamos los 10 bits menos significativos

Registro b_0: Redundamos los 10 bits menos significativos
95
O sea, ahora debemos de atacar solo a los 8 MSB de cada registro.

Realizando dicha prueba, los resultados fueron:

Efectivamente, se confirma que los bits ms sensibles son los MSB

ya que redundar los LSB no sirve para mucho pues como se observa se
tiene una tasa de error altsima.
PRUEBA 4: En esta prueba vamos a atacar solo a los 10 LSB del

registro b, o sea, redundaremos todos los registros a, y los 8 MSB de los
registros b.
Registro a_0: Totalmente redundado

96
Con los siguientes resultados:

Como cabra esperar la tasa de fallo es nfima, eso es debido a que en

esta prueba hemos redundado todos los bits importantes (los MSB de todos
los registros) y adems los 10 LSB de a.
PRUEBA 5: En esta prueba vamos a atacar solo a los 10 LSB del

registro a, o sea, redundaremos todos los registros b, y los 8 MSB de los
registros a.

Registro b_0: Totalmente redundado
97
Con los siguientes resultados:

PRUEBA 6: En esta prueba y la siguiente, vamos a intentar descubrir

que registros son ms sensibles si los a o los b. Para ello vamos a atacar en
esta prueba a los bits ms sensibles de los registros de a, o sea vamos a
atacar los 8 MSB de a, y en la siguiente atacaremos los 8 MSB de b y
compararemos los resultados.

98
Realizando la prueba los resultados fueron:

Estos resultados los vamos a comparar con los obtenidos en la

prueba 7.
PRUEBA 7: Aqu vamos ahora a atacar los 8 MSB de los registros b.

99
Realizando la prueba los resultados fueron:

A la vista de los resultados obtenidos parece ser que los registros a o

sea, los de la realimentacin, son bastante ms sensible que los registro b,
ya que introducir un fallo en uno de sus bits ms significativos tiene
bastante ms probabilidad de producir un error en la salida que si se
produce el fallo en uno de los bits ms significativos de los registros b.
Para confirmar dichos resultados, lo que tendramos q hacer es

realizar otras dos pruebas que sera, una atacar a todos los bits de los
registros a, y otra hacer un ataque a todos los bits de los registros b y
comparar los resultados. As que en las dos pruebas siguientes vamos a
hacer este experimento.
PRUEBA 8: En esta prueba vamos a atacar todos los bits de los registros a.
Por lo tanto redundaremos todos los bits de los registros de b y dejaremos
totalmente sin redundar los registros a.

100

Realizamos el ataque, y los resultados fueron:

PRUEBA 9: Para comparar que registro es ms sensible, ahora haremos la

prueba complementaria, es decir, realizaremos un ataque sobre los registros
de b. Esto sera redundar por completo los registros a, y dejar simple los
registros b

101

Realizamos el ataque, y los resultados fueron:

As que con el resultado de estas dos pruebas queda claro lo que ya

empezamos a ver con las dos anteriores, y es que los registros de a (de la
realimentacin) son ms sensibles que los registros de b. As que si
tuviramos que elegir que registros redundar, sera ms eficiente redundar
los registros a que los registros b.
102
4.4.2. CONCLUSIONES FILTRO IIR

Tras haber realizado todas estas pruebas para intentar estudiar la
sensibilidad de un filtro IIR en presencia de SEU, llegamos a las siguientes
conclusiones:
1.- Los registros ms sensibles, o sea con mayor porcentaje de que al

introducir en ellos un fallo se tenga un error en la salida, son los registros
de la realimentacin, los registros de a.
2.- Los bits ms sensibles de cada registro, o sea los que tienen
mayor porcentaje de que al provocar un fallo en ellos se tenga un error en
la salida, son los bits ms significativos (los MSB), en concreto los 8 MSB,
los que van del bit 10 al 17 de cada registro.
3.- Si queremos un filtro IIR que sea bastante tolerante a los SEU los
ms importante de redundar son siempre los registros de la realimentacin
(registros a) y tambin redundar siempre los bits ms significantes de las
etapas, en concreto los 8 bits MSB. Ya que haciendo esto, hemos visto que
podemos obtener filtros bastante eficientes y ahorrando gran cantidad de
recursos.
103

Estudio Filtro Iir

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Estudio Filtro Iir

Caricato da

Copyright:

Formati disponibili

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

ESTUDIO DEL FILTRO IIR

- Frecuencia de paso: fp = 5 Khz.,

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

- Frecuencia de muestreo: fsim = 48 Khz.,

Este filtro ser el que tendremos que implementar en la FPGA para

Cuando tengamos implementado el filtro en la FPGA el siguiente

Llegados a este momento, ya tenemos nuestro filtro IIR

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

Todos estos pasos se irn describiendo en los siguientes apartados.

4.2. CARACTERIZACIN DEL FILTRO FIR EN MATLAB

% Funcion que genera un filtro elptico paso bajo, con

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

En Realidad, el coeficiente a1 del filtro no es 0, sino que es 1. Lo que

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

al estar el bloque de los coeficientes a en el bucle de realimentacin (ver

Y el filtro que se obtiene es el siguiente:

Figura 20: filtro IIR implementado

Jos Manuel Marn de la Rosa

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

Para comprobar que esto funciona bien, hacemos uso de la

Figura 21: Montaje simulink filtro IIR

En la figura 21 lo que hemos realizado ha sido meter 2 bloques

Para probarlo, le hemos introducido 2 seales de entrada, en concreto

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

Figura 22: Salida filtro IIR

Como se observa en la figura 22, en el osciloscopio se mete tanto la

Si hacemos un anlisis espectral de nuestro sistema, poniendo a la

Jos Manuel Marn de la Rosa

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

Figura 23: Anlisis espectral de la salida del filtro

Jos Manuel Marn de la Rosa

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

4.3. IMPLEMENTACIN DEL FILTRO EN LA FPGA

La estructura que tenemos que implementar en hardware es una

Figura 24: Estructura directa I filtro IIR

Que como vimos en los fundamentos tericos, se trata de la

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

Lo primero que tenemos que realizar es codificar los coeficientes de

As que haremos eso, multiplicaremos todos los coeficientes por esos

Tabla 5: Coeficientes a Codificados en CA2

Jos Manuel Marn de la Rosa

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

Tabla 6: coeficientes b Codificados en CA2

Para implementar en hardware la estructura de la figura 21

Jos Manuel Marn de la Rosa

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

---------------------------------------------------------------------------------------------------------------------- Filtro IIR:

Seal digital de entrada de 18 bits

Filtro paso de baja tipo Butterworth, con frecuencia

port (clk,reset,load: in std_logic;

Jos Manuel Marn de la Rosa

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

architecture a_iir of iir is

signal data_outi: std_logic_vector(17 downto 0);

port (clk,reset,load: in std_logic;

firstruct: process (data_outa,data_outb)

ESTUDIO DEL FILTRO IIR EN PRESENCIA DE S.E.U.

significa que desborda por arriba

elsif idata_tmp(19 downto 18) = "10" then

data_outi <= std_logic_vector (data_tmp);

ultima_etapa <= (others =>'0');

Jos Manuel Marn de la Rosa