Estudio Filtro Fir

ESTUDIO DEL FILTRO FIR EN PRESENCIA DE S.E.U.
33

J os Manuel Marn de la Rosa

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

3.1. INTRODUCCIN

En este apartado vamos a hacer un estudio de un filtro FIR en
particular, en concreto un filtro FIR paso de baja con los siguientes
parmetros:

- Frecuencia de paso: fp =5 Khz,
- Frecuencia de corte: fs =6 Khz.,
- Atenuacin en la banda de paso: rp =1 dB,
ESTUDIO DEL FILTRO FIR EN PRESENCIA DE S.E.U. 34


- Atenuacin en la banda de rechazo: rs =5 dB,
- Frecuencia de muestreo: fsim =48 Khz.,

Este filtro ser el que tendremos que implementar en la FPGA
para despus estudiar su sensibilidad en presencia de SEU (Single Event
Upset). Para implementarlo tendremos que saber sus coeficientes ya que
como vimos en el apartado terico, un filtro FIR se representa mediante
tantos retrasos como orden tenga y estas muestras retrasadas de la entrada
se van multiplicando por unos coeficientes para, una vez sumadas, obtener
la respuesta final deseada.

Una vez que sepamos el orden del filtro y los coeficientes, lo que
tendremos que hacer es implementarlo en un lenguaje de descripcin
hardware (VHDL) en el que slo tendremos que generar los sumadores,
multiplicadores y los retrasos (estos se harn con flip-flops).

Cuando tengamos implementado el filtro en la FPGA el siguiente
paso ser comprobar si efectivamente funciona como debe de funcionar, es
decir si filtra lo que tiene que filtrar (en nuestro caso todas las componentes
frecuenciales por encima de 6 Khz.), para ello lo que haremos ser
comprobar nuestro filtro real implementado en la FPGA con el mismo
filtro terico realizado en MATLAB, y comprobando que ambos filtros
responde idnticamente (o al menos parecido) ante los mismos estmulos
de entrada.



Llegados a este momento, ya tenemos nuestro filtro FIR
implementado en la FPGA, ahora es cuando vamos a hacer un estudio
exhaustivo sobre l realizndole diversas pruebas para ver como de
sensible es en presencia de SEU.

Todos estos pasos lo vamos a ir detallando paso a paso en los
siguientes apartados.



3.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.

Lo primero que tenemos que averiguar es el orden del filtro, para
ello, hacemos uso por ejemplo de la aproximacin de butterworth y
escribiendo la siguiente funcin en MATLAB:

r p=1;
r s=5;
f p=5000;
f s=6000;
f si m=48000;

wp=2*f p/ f si m;
ws=2*f s/ f si m;

[ N, Wn] =but t or d ( wp, ws, r p, r s) ;

En la cual, definimos unas variables con las especificiaciones del
filtro, calculamos las frecuencias discretas wp y ws y se las pasamos, junto
a las atenuaciones de la banda de paso y de rechazo, como parmetros a la
funcin buttor, y esta nos devuelve en N el orden del filtro, en nuestro caso
N =11.


Una vez que sabemos el orden del filtro para una aproximacin en
concreta, solo nos falta por saber los coeficientes del filtro FIR, para ello
usamos la funcin de MATLAB fir2, a la cual se le pasa como
parmetros el orden del filtro, y un vector de puntos de refenrencias
frecuenciales normalizadas y otro vector con la amplitud de dichas
frecuencias, por ejemplo:
Fir2 (11, [0, 0.2, 0.3, 0.8, 1], [1, 1, 1e-5, 1e-5, 1e-5]);
y nos devuelve los coeficientes de nuestro filtro, que son:

Coeficiente Valor
a
0
-0.0033
a
1
-0.0058
a
2
0.0116
a
3
0.0969
a
4
0.2305
a
5
0.2988
a
6
0.2305
a
7
0.0969
a
8
0.0116
a
9
-0.0058
a
10
-0.0033

Tabla 1: Coeficientes del filtro FIR
Estos son los coeficientes que tendremos que digitalizar para poder
implementar el filtro en la FPGA.



Para comprobar que esto funciona bien, hacemos uso de la
herramienta SIMULINK de MATLAB y hacemos el siguiente montaje:

Figura 13: Montaje en simulink filtro FIR

En la figura 13 lo que hemos realizado ha sido meter un bloque
Discrete filter en el que le hemos pasado como parmetro, dentro de la
variable a2(z) los coeficientes de la tabla 1.

Para probarlo, le hemos metido 2 seales de entrada, un seno de gran
amplitud a una frecuencia de 3.980 Hz y una seal de ruido de gran
potencia, y comprobamos que a la salida se filtra la seal sinusoidal
limpindola de ruido. Si simulamos, lo que se obtiene es lo siguiente:



Figura 14: Salida del filtro FIR

Como se observa en la figura 13, en el osciloscopio se mete tanto la
entrada como la salida, para poder visualizar las dos seales a la vez. La
entrada (seal sinusoidal ms ruido) es la seal amarilla, y la seal de
salida, la filtrada (que debe de ser solo la sinusoidal) es la seal rosa. Para
ver mejor el resultado, vamos a hacer un zoom de la figura 14 y lo
mostramos en la figura 15:



Figura 15: Zoomde la seal de salida del filtro

Y en ella se ve claramente como el filtro funciona bien, y a la salida
tenemos solamente la seal sinusoidal (discretizada claro est al tratarse de
un filtro discreto) y hemos conseguido quitar el ruido.

Si hacemos un anlisis espectral de nuestro sistema, poniendo a la
salida de nuestro filtro FIR un analizador de espectro obtenemos la imagen
de la figura 16, en la que podemos ver la seal de salida en el tiempo, la
densidad espectral de potencia y la fase. Como caba de esperar tenemos
una sampling centrada a la frecuencia del seno (3.980 hz).



Figura 16: Anlisis espectral de la salida del filtro

Si cambiamos el seno de entrada por otro seno de frecuencia 10 Khz.
a la salida se tendra que tener un seno casi atenuado, ya que la
frecuencia de corte de nuestro filtro era de 6 Khz. y la del seno esta por
encima de esta frecuencia. Si simulamos, obtenemos la siguiente respuesta:

Figura 17: Salida del sistema a 10 Khz.



El anlisis espectral de la salida con una entrada de un seno de 10
Khz. ms una componente de ruido es el siguiente:

Figura 18: Anlisis espectral de la salida con entrada de 10 Khz.

En el que se observa claramente en la seal de salida en el tiempo
que ya no se tiene un seno tan claro como antes, y que la densidad espectral
de potencia no es tan limpia como en el caso en el que la seal de entrada
era a una frecuencia por debajo de los 5 Khz. de frecuencia de paso de
nuestro filtro. As que con todo esto nuestro filtro queda perfectamente
caracterizado.



3.3. IMPLEMENTACIN DEL FILTRO EN LA FPGA

Una vez que ya tenemos nuestro filtro perfectamente caracterizado y
definido ( El filtro es de orden 11, y sabemos todos sus coeficientes) el
siguiente paso ser implementarlo en una FPGA, y para ello habr que
escribirlo en lenguaje de programacin hardware, que en nuestro caso ser
el VHDL.

La estructura que tenemos que implementar en hardware es la
siguiente:

Figura 19: Estructura directa filtro FIR

Que como vimos en los fundamentos tericos, se trata de la estrutura
directa I. En el dibujo, solo se han representado 8 etapas, pero sabemos que
nuestro diseo debe de tener 11 etapas, siguiendo la estructura de la figura
19, que es fcil de implementar.

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 11 coeficientes de
nuestro filtro los vamos a codificar con 9 bits.

Lo primero que tenemos que realizar es codificar los coeficientes de
la tabla 1 en 9 bits, como lo vamos a codificar con 9 bits, si cuantizamos
(multiplicamos por 2
9
) todos los coeficientes y redondeamos al entero ms
cercano (redondeamos por arriba si el nmero es positivo y por abajo si el
nmero es negativo) obtenemos la siguiente tabla:

Coeficiente Valor Codificacin con 9
bits en CA2
a
0
-2
111111110
a
1
-2
111111110
a
2
6
000000110
a
3
50
000110010
a
4
118
001110110
a
5
154
010011010
a
6
118
001110110
a
7
50
000110010
a
8
6
000000110
a
9
-2
111111110
a
10
-2
111111110

Tabla 2: Coeficientes del filtro Codificados en CA2 con 9 bits

Para implementar en hardware la estructura de la figura 19 con
N=11, lo que vamos a tener que hacer es modelar los retrasos con flip-
flops, en nuestro caso 11 flip-flops, a los que le entra un vector de 18 bits y
sale otro vector de 18 bits retrasados un ciclo. La salida de cada biestable


que son las seales X(n-L) son multiplicadas por los coeficientes
correspondientes h(L), para implementar dicha multiplicacin, usaremos
multiplicadores de 18X9 bits, y el resultado lo meteremos en un vector de
27 bits para evitar el overflow. Luego se hace la suma de todas las
multiplicaciones (teniendo en cuenta el redondeo, segn el resultado sea un
nmero positivo o un nmero negativo) y por ultimo, el resultado se mete
en un vector de salida de 18 bits (as que aqu hacemos truncado del
resultado). 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:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Fi l t r o Fi r :
- - Seal di gi t al de ent r ada de 18 bi t s
- - Coef i ci ent es de 9 Bi t s
- - Mul t i pl i cador es de 18X9 ( t ant os como coef . se t engan,
o sea, t ant os como r et r asos hal l a)
- - Acumul ador ( sumador ) de di chas mul t i pl i caci ones
- - Fi l t r o paso de baj a t i po But t er wor t h, con f r ecuenci a
de cor t e de 5 Khz.
- - Caso 1: Fi l t r o f i r si n r edundar
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

- - Bl oque par a descr i bi r l os coef i ci ent es del f i l t r o FI R

l i br ar y i eee;
use i eee. st d_l ogi c_1164. al l ;

use i eee. numer i c_st d. al l ;

package f i r _coef i s
subt ype coef _wor d i s si gned( 8 downt o 0) ; - - coef i ci ent es
de 9 bi t s
subt ype coef _r ange i s i nt eger r ange 0 t o 10; - - numer o
de coef i ci ent es que hay, o sea, r et r asos


t ype coef _t abl e i s ar r ay ( 0 t o 10) of coef _wor d;

const ant coef _r om: coef _t abl e: = (
( " 111111110" ) ,
( " 111111110" ) ,
( " 000000110" ) ,
( " 000110010" ) ,
( " 001110110" ) ,
( " 010011010" ) ,
( " 001110110" ) ,
( " 000110010" ) ,
( " 000000110" ) ,
( " 111111110" ) ,
( " 111111110" ) ) ;
end package f i r _coef ;

- - Fi l t r o Fi r

l i br ar y i eee;
use i eee. st d_l ogi c_1164. al l ;
use i eee. numer i c_st d. al l ;
use wor k. f i r _coef . al l ;

ent i t y f i r i s
por t ( cl k, r eset , l oad: i n st d_l ogi c;
dat a_i n: i n st d_l ogi c_vect or ( 17 downt o 0) ;
- - seal di gi t al de ent r ada de 20 bi t s
dat a_out : out st d_l ogi c_vect or ( 17 downt o 0) ;
ul t i ma_et apa: out st d_l ogi c_vect or ( 17 downt o 0) ) ;

end f i r ;

ar chi t ect ur e a_f i r of f i r i s
t ype f i f o_ar r ay i s ar r ay ( 0 t o 10) of si gned ( 17
downt o 0) ;

si gnal f i f o, p_f i f o: f i f o_ar r ay;
si gnal dat a_out i : st d_l ogi c_vect or ( 17 downt o 0) ;

component r egTmr i s
Gener i c( N: i nt eger : =18) ;
Por t ( cl k : i n st d_l ogi c;
r eset : i n st d_l ogi c;
d : i n si gned ( N- 1 downt o 0) ;


q : out si gned ( N- 1 downt o 0) ) ;
end component ;

component r egSi mpl e i s
Gener i c( N: i nt eger : =18) ;
Por t ( cl k : i n st d_l ogi c;
r eset : i n st d_l ogi c;
d : i n si gned ( N- 1 downt o 0) ;
q : out si gned ( N- 1 downt o 0) ) ;
end component ;
begi n

si nc: pr ocess ( r eset , cl k)
begi n
i f r eset = ' 1' t hen
dat a_out <= ( ot her s => ' 0' ) ;

el si f cl k' event and cl k = ' 1' t hen
dat a_out <= dat a_out i ;

end i f ;
end pr ocess si nc;

r 0: r egSi mpl e
Gener i c map ( N=>18)
por t map ( cl k => cl k, r eset => r eset , d => p_f i f o( 0) , q
=> f i f o( 0) ) ;

r 1: r egSi mpl e
=> f i f o( 1) ) ;

r 2: r egSi mpl e
=> f i f o( 2) ) ;

r 3: r egSi mpl e
=> f i f o( 3) ) ;

r 4: r egSi mpl e
=> f i f o( 4) ) ;

r 5: r egSi mpl e


=> f i f o( 5) ) ;

r 6: r egSi mpl e
=> f i f o( 6) ) ;

r 7: r egSi mpl e
=> f i f o( 7) ) ;

r 8: r egSi mpl e
=> f i f o( 8) ) ;

r 9: r egSi mpl e
=> f i f o( 9) ) ;

r 10: r egSi mpl e
=> f i f o( 10) ) ;

r egs: pr ocess( l oad, f i f o, dat a_i n)
begi n
i f l oad = ' 1' t hen
f or i i n 1 t o 10 l oop
p_f i f o( i ) <= f i f o( i - 1) ;
end l oop;
p_f i f o ( 0) <= si gned ( dat a_i n) ;
el se
p_f i f o( i ) <= f i f o( i ) ;
end l oop;
end i f ;
end pr ocess r egs;

f i r st r uct : pr ocess ( f i f o)
var i abl e pr od: si gned ( 26 downt o 0) ;
var i abl e i dat a_t mp: si gned ( 19 downt o 0) ;
var i abl e dat a_t mp: si gned ( 17 downt o 0) ;
begi n
dat a_t mp : = ( ot her s => ' 0' ) ;


pr od : = f i f o( i ) * coef _r om( i ) ;
i f ( pr od( 26) =' 1' ) t hen
pr od: =pr od+255; - - r edondeo
end i f ;
i dat a_t mp : = ( dat a_t mp( 17) &dat a_t mp( 17) &dat a_t mp)
+ ( pr od( 26) &pr od( 26) &pr od( 26 downt o 9) ) ;
i f i dat a_t mp( 19 downt o 18) = " 01" t hen - -
si gni f i ca que desbor da por ar r i ba
dat a_t mp: =( 17=>' 0' , ot her s=>' 1' ) ;

el si f i dat a_t mp( 19 downt o 18) = " 10" t hen -
- si gni f i ca que desbor da por abaj o
dat a_t mp: =( 17=>' 1' , ot her s=>' 0' ) ;

el se
dat a_t mp: =i dat a_t mp( 17 downt o 0) ;
end i f ;
end l oop;
dat a_out i <= st d_l ogi c_vect or ( dat a_t mp) ;
end pr ocess f i r st r uct ;

ul t i ma_et apa <= ( ot her s =>' 0' ) ;
end a_f i r ;

Este cdigo, junto con la descripcin de los componentes, y los
sucesivos cdigos que debemos de generar para realizar las pruebas
oportunas 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 dijimos anteriormente, lo que vamos a hacer es compararlo con
el filtro terico que caracterizamos en MATLAB, para ello, a los dos le
vamos a meter la misma entrada, y por lo tanto deberamos de obtener
parecidas salidas.

Para meterle al filtro que tenemos en la FPGA la misma entrada que
al que tenemos generado en MATLAB, tenemos que meter la entrada en un


fichero, para hacer eso, como vemos en la figura 12 la seal de entrada la
hacemos pasar por un cuantizador para cuantizarla, despus la hacemos
pasar por un convertidor, para convertirla a un entero, y posteriormente ese
resultado lo guardamos en una variable con nombre Entrada1, el
contenido de esa variable lo pasamos a un fichero, para que, generando el
cdigo VHDL oportuno, se le pase dicho fichero como parmetro de
entrada a nuestro filtro, y genere otro fichero, que se llame
fichero_de_salida el cual debemos de comparar con el contenido de la
variable Salida que se genera a la salida del filtro fir de MATLAB. Si
vemos un trocito de dichos ficheros (los ficheros completos se expondrn
en el anexo) podemos ver los resultados.

El contenido de la variable Entrada1,que se obtuvo haciendo la
simulacin en SIMULINK, y que ser el contenido de el
fichero_de_entrada que se le va a pasar al filtro fir de la FPGA es el
siguiente:
55232
131071
- 19665
131071
131071
6925
- 131072
- 42095
- 22712
- 91978
- 36006
8165
- 25592
131071
30943
- 131072
- 123440


131071
- 60393
- 131072
- 131072
- 131072
- 131072
- 131072
- 41356
131071
120188
131071
131071
125974
- 80548
- 127333
- 131072
- 131072
131071
77463
- 117338
- 97165
82961
131071
77966
- 122143
- 127018
- 56718
74885
- 131072
22310
.
.
.
.
.

En la variable Salida obtenida en SIMULINK se tiene los
siguientes datos:


- 215
- 727
212
6494
24274
45896
62441
73451
77939
57781
10047
- 36816
- 55662
- 55306
- 47519
- 32944
- 6155
21507
26957
- 2367
- 35016
- 38912
- 29105
- 45700
- 85468
- 117894
- 127643
- 117936
- 79567
- 13482
58438
107103
123037
104276
49421
- 26336
- 85322
- 91846
- 47561
- 834
3607
- 17750


.
.
.
.
.

Que si lo comparamos con el fichero_de_salida que genera la
FPGA:

-216
-728
211
6492
24274
45895
62439
73448
77936
57778
10044
-36821
-55665
-55308
-47519
-32946
-6158
21503
26954
-2372
-35020
-38916
-29108
-45702
-85471
-117896
-127644
-117938
-79569
-13484
58435


107099
123034
104274
49418
-26338
-85325
-91849
-47564
-837
3604
-17754
.
.
.
.

Como se observa, la salida de ambos filtros son prcticamente
idnticas, los 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.



3.4. ESTUDIO EXHAUSTIVO DEL FILTRO FIR.
PRUEBAS REALIZADAS.

Llegados a este punto, empezamos, ahora s, a estudiar el verdadero
propsito de sta investigacin, que no es otro sino que estudiar el
comportamiento de filtros en presencia de SEU.

Vamos a comenzar estudiando el filtro FIR, para despus, hacer lo
propio con un filtro IIR y as poder comparar los resultados obtenidos.

Como sabemos, cuando un circuito electrnico se encuentra en
presencia de SEU, ste puede hacer que vare algunas de las propiedades
fsicas de dicho circuito, haciendo que el resultado obtenido a la salida no
sea el esperado. Nosotros, para simular ese SEU, vamos introducir
errores en distintas partes de nuestro filtro (como si esos errores fueran
provocados por el SEU) y vamos a ver como se comporta nuestro filtro,
comparando la salida ideal que dara sin introducir fallos con la salida
que se obtiene introduciendo estos fallos voluntariamente.

Para introducir estos errores vamos a hacer uso de una herramienta
diseada en la Universidad de Sevilla por AICIA-GTE, ESA en un proyecto
denominado FT-UNSHADES ms en concreto de las publicaciones:
FT-UNSHADES Design Preparation Tools y FT-UNSHADES
Design Test and Analysis Tools cuya documentacin est incluida en los
anexos de esta memoria.

A grosso modo esta herramienta lo que hace es crear en la FPGA 2
copias del sistema a estudiar y unos vectores para testearlas. Una de las


copias ser la ide., sin fallos, y metindole los vectores de entrada,
obtenemos las salidas correspondientes a esos vectores. En la otra copia es
en la que se introduce fallos en distintos sitios (como si esos fallos fuesen
producidos por el SEU) se le meten los mismos vectores de entrada y
compara la salida de esta con la anterior, si es la misma es que el fallo
introducido no ha producido errores, si la salida es distinta, quiere decir que
el fallo que se ha introducido (y sabemos dnde) produce fallo. Los fallos
que se meten en la copia del diseo, se introducirn muchas veces en
distintos tiempos, por eso algunas veces introducir un error en un registro
en concreto de nuestro diseo puede dar fallos o no, dependiendo de el
ciclo de reloj en el que se encuentre.

Con sta informacin vamos a intentar hacer un mapa de nuestro
filtro viendo donde si se produce fallo en ese sitio es mas 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 la ideal,
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.

Esa ser nuestra primera misin, despus, una vez realizado eso
vamos a introducir triple redundancia modular en nuestro filtro y eleccin
por mayora, o sea, replicar nuestro diseo tres veces y elegir la salida
mediante votacin de los tres. Veremos que si redundamos todos los
registros de nuestro filtro, aunque se produzcan fallos dentro de algn
registro, nunca se tendr error a la salida, o sea, esto sera lo ideal, ya que
tendramos un 0% de fallos a la salida en presencia de SEU, pero claro est


tambin es la solucin mas cara, ya que redundar todo el sistema, es 3
veces mas caro que el circuito original.

Por todo esto, lo q vamos a intentar es hacer un estudio que consistir
en ver que registros internos del filtro merecen la pena redundar, y cuales
no. Redundaremos aquellos en los cuales un error en ese registro tenga un
alto porcentaje de que produzca un error a la salida, y no redundaremos
aquellos registros en los cuales un error en ellos tenga un porcentaje muy
bajo de que se produzca error a la salida.

Para hacer esto creamos en VHDL 2 mdulos, uno que ser el
registro simple, que ser un registro normal (biestable) con un vector de
entrada y de salida de 18 bits, y un registro que llamaremos registroTmr, el
cual tendr triple redundancia modular, ya que ser un registro que est
triplicado. (los cdigos estn en el anexo). Y jugaremos poniendo en
nuestro filtro algunos registros como registros simples y otros como
registrosTmr y viendo los resultados.



3.4.1. PRUEBAS REALIZADAS

El siguiente paso que dimos, una vez realizado todo lo anterior, fue
la realizacin de diversas pruebas, redundando partes de nuestro circuito, y
comparar los recursos (biestables) consumidos con la eficiencia del filtro,
ya que como dijimos antes, si se redunda todo el sistema estamos seguros
de que se tendr un 100% de eficiencia, pero claro est pagando el mas alto
precio en recursos.

Habr aplicaciones, en las que claro est, se requerir que el sistema
tenga un 100% de eficiencia, por ejemplo en sistemas integrados en
aplicaciones crticas como pueden ser sistemas para proyectos espaciales,
circuitos electrnicos de lser para operaciones oculares (imaginad por un
instante que ese lser falla por un momento, sera un desastre para la
operacin y podra dejar ciega de por vida a la persona en cuestin), etc,.
Est claro que para estas aplicaciones no se repara en recursos y se
redundara el sistema un 100% para evitar desastres.

Sin embargo, hay otras muchas aplicaciones, como por ejemplo
contadores de surtidor de gasolina, circuitos de electrodomsticos, y de
propsito general, en los que no se requieren un 100% de eficiencia, son
en estos circuitos en los que se busca una mejor relacin eficiencia-precio y
para ello se estudia que es lo que merece la pena redundar y que no.



Para estudiar nuestro filtro FIR, hemos realizado diversas pruebas, en
concreto 11, para ver donde se producen ms fallos, y estudiar la mejor
relacin eficiencia-precio de nuestro sistema. Las pruebas consisten en
introducir 10.000 errores en distintos lugares y en distintos momentos en
nuestro diseo y ver si esos errores producen fallos en la salida o no.

PRUEBA 1: 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 fueron los siguientes:

- Recursos utilizados : 204 flip-flops,
- Eficiencia: 18 %

Como se observa, se tienen muchos errores, se consigue una
eficiencia muy baja. Si se observa el fichero resultante de realizar la prueba
1 (en CD adjunto) se ve que los errores son ms crticos cuanto ms cerca
de la entrada se produce, o sea, que los registros ms crticos son los las
cercanos a la entrada, el registro0, el registro1, el registro2 y as
sucesivamente, y dentro de los registros son mucho mas crticos los errores
que se producen en los bits altos, ya que un error en un bit alto produce
error seguro a la salida. A modo de resumen, detallo donde alguna vez no
se produce fallos, aunque se introduzca ah un error (otras veces s):

Registro 0, reigstro 1, registro 2, registro 3, registro 4, registro 5:
En estos registros no siempre se tiene fallo en la salida si se introduce un
error en los bits 0 y 1. Si se introduce el error en los otros bits, siempre se
tiene fallo en la salida.



Registro 6: No siempre se tiene fallo en la salida si se introduce un
error en los bits 0, 1 y 2. Si se introduce en los dems si.
error en los bits 0, 1, 2 y 3. Si se introduce en los dems si.

error en los bits que van del 0 al 6, en los dems si.

Registro 9 y registro 10: No se produce fallo en la salida si se
introduce un error en los bits que van del 0 al 7 en los dems s.

En conclusin, los bits mas significativos son crticos!, ya que un
error en ellos da lugar a fallo seguro en la salida, y mirando los registros,
los registros mas cercanos a la entrada son ms crticos que los que estn
mas cercanos a la salida. (Cdigo VHDL en anexos)

PRUEBA 2: La siguiente prueba que hicimos fue redundando todo el
sistema. Como cabra de esperar tuvimos un 100 % de eficiencia por eso no
anexo el fichero de salida de esta prueba, ya que es obvio como sera.

- Recursos utilizados: 612 flip-flops,
- Eficiencia: 100%

Como se observa, se tiene 3 veces mas de recursos que en el caso
anterior. (Cdigo en Anexos)



PRUEBA 3: Visto el resultado de la primera prueba, lo primero que
debemos de hacer es empezar a redundar los registros mas bajo, y as
vamos a empezar. En esta tercera prueba lo que vamos a hacer es lo
siguiente:
Registro 0: Totalmente redundado (ya que es el ms importante)
Registro 1: Totalmente redundado menos el bit menos significativo
Registro 2: Totalmente redundado menos los 2 bits menos
significativos.
significativos.
significativos.
significativos.
significativos.
significativos.
significativos.
significativos.
significativos.



Realizamos esta prueba en VHDL (cdigo en Anexos) y la
analizamos, obteniendo los siguientes resultados:

- Recursos utilizados: 502 flip-flops
- Eficiencia 93.56%

Como vemos, hemos conseguido quitar un nmero considerable de
flip-flops (110) y seguimos teniendo un elevado porcentaje de eficiencia
que es de mas del 93%. (El fichero con el resultado en CD adjunto).

Viendo el fichero de salida, se observa, como cabra esperar, que los
fallos se tienen en los bits ms significativos de cada registro, que son los
que no estn redundados. Y como en esos bits eran en los que menos fallos
se tenan sin redundar por esa razn baja nuestra tasa de fallos.

PRUEBA 4: En esta prueba vamos a intentar utilizar menos recursos, o sea
redundar un poco menos, pero intentando mantener el porcentaje de
eficiencia. La prueba que vamos a realizar es la siguiente:

significativos.
significativos.
significativos.


significativos.
significativos.
significativos.
significativos.
significativos.
significativos.
significativos.


- Eficiencia 91.28%

Hemos reducido los recursos utilizados con respecto a la prueba
anterior en 20 flip-flops con apenas notarse la eficiencia, ya que sigue
siendo bastante alta con ms del 91% de eficiencia.



PRUEBA 5 : En esta prueba vamos a seguir intentando utilizar menos
recursos que en la anterior, siempre manteniendo el porcentaje de eficiencia
relativamente alto. En esta haremos lo siguiente:

significativos.
significativos.
significativos.
significativos.
significativos.
significativos.
significativos.
significativos.
Registro 9 : Totalmente redundado menos los 12 bits menos
significativos.
significativos.




- Eficiencia: 88.33%

Hemos vuelto a reducir los recursos utilizados, en concreto en 20
flip-flops con respecto a la prueba anterior, y la eficiencia la podemos
seguir considerando bastante alta (segn para la aplicacin que se quiera
claro est) con un 88.33%

PRUEBA 6: En esta prueba haremos:

significativos.
significativos.
significativos.
significativos.
significativos.
significativos.


significativos.
Registro 8 : Totalmente redundado menos los 12 bits menos
significativos.
significativos.
significativos



Como se sigue observando, seguimos reduciendo los recursos, y la
eficiencia sigue siendo relativamente alta.

PRUEBA 7: En esta prueba vamos a cambiar un poco nuestra forma de
actuar hasta ahora. Hasta el momento hemos visto que si vamos dejando sin
redundar los bits LSB de los registros, vamos ahorrando en recursos y
conseguimos mantener la eficiencia bastante alta (siempre por encima del
85%, por lo visto hasta ahora). En esta prueba y la siguiente vamos a
investigar otra cosa, y es ver que registro son los ms importantes, si los
registros pares o los registros impares.


En esta prueba vamos a redundar los registros pares y no los impares
y vamos a ver que resultados se obtiene, mientras que en la siguiente
vamos a hacer lo contrario, o sea, redundar los impares y no los pares, y
veremos en cual de las dos se obtiene mejores resultados.

Registro 0: Totalmente redundado
Registro 1: Totalmente sin redundar





PRUEBA 8: Y ahora hacemos lo contrario, redundamos los registros
impares totalmente, y dejamos sin redundar los pares




A vista de los resultados obtenidos, parece mejor redundar los
registros pares que los impares, esto ms o menos se esperaba por dos
motivos:
1.- Hay mas registros pares que impares, si se redundan los pares, se
redundan ms registros que cuando redundamos los impares, eso se ve en
los recursos usados, ya que para la prueba 7 se usan 432 flip-flops, mientras


que para la 8 slo 396. As que si se tiene ms redundancia, claro est que
se tendr mejores resultados.
2.- El segundo motivo es porque como vimos en la prueba 1, los
registros que estn ms cerca de la entrada son ms importantes y ms
sensible a los errores introducidos. Al tomar el registro 0 como registro par
lo redundamos en la prueba 7 y no en la 8 y por eso en la 7 se obtienen
mejores resultados que en la prueba 8.

Si queremos comprobar si es mejor redundar los pares que los
impares, lo que podemos hacer es realizar una nueva prueba en la que se
redundan solo los registros impares y no los pares pero adems tambin
redundamos el registro 0 totalmente. Eso es lo que haremos en la siguiente
prueba.

PRUEBA 9: Redundamos todos los registros impares y adems el registro
0, y los dems los dejamos sin redundar.






Ahora si podemos comprobar los resultados de esta prueba, con los
obtenidos en la prueba 7, ya que tenemos el mismo nmero de flip-flops en
las dos. Pues bien, se observa que por muy poco, apenas el 3% es mejor
redundar los impares (ms el registro 0) que los pares (ms el registro 0).
Esto tambin puede tener una explicacin, y es que, como dijimos en la
prueba 1, los registros ms sensibles son los ms cercanos a la entrada, si
en las dos pruebas tenemos redundado el registro 0 que es el ms cercano,
el siguiente en importancia es el registro 1, y ese se redunda por completo
en los impares (prueba 9) y no en los pares (prueba 7) de ah los resultados
obtenidos.

Por ltimo, vamos a comprobar que es ms til redundar, si los 9 bits
ms significativos o los 9 bits menos significativos de cara registro. Para
ello vamos a hacer 2 pruebas, 1 en la que vamos a redundar los 9 bits ms
significativos de todos los registros dejando si redundar los 9 LSB,
y despus haremos la prueba complementaria, es decir redundar los 9 bits
menos significativos y dejar sin redundar los 9 MSB de cada registro.



PRUEBA 10: Redundaremos los 9 bits MSB de cada registro, y dejar sin
redundar los 9 bits LSB.

Registro 0: 9 MSB redundados y los 9 LSB sin redundar.
Registro 10: 9 MSB redundados y los 9 LSB sin redundar



RUEBA 11: Redundaremos los 9 LSB de cada registro y dejaremos sin
redundar los 9 MSB.

Registro 0: 9 LSB redundados y los 9 MSB sin redundar.





Como podemos observar se obtiene mejores resultados si
redundamos los 9 bits MSB que si redundamos los 9 bits LSB, esto ya era
algo previsible, pues como hemos ido observando en las pruebas anteriores,
los bits MSB son ms sensibles que los LSB, ya que si uno de ellos falla
por cualquier motivo con una gran probabilidad se va a tener error en la
salida de nuestro filtro. As que es mucho ms importante redundar los bits
ms significativos que redundar los bits menos significativos.



3.4.2. CONCLUSIONES FILTRO FIR

Tras haber realizado todas estas pruebas para intentar estudiar la
sensibilidad de un filtro FIR 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
ms cercanos a la entrada. Algo que puede ser comprensible, ya que si se
produce un fallo en la primera etapa del filtro ese error se va a ir
multiplicando en las dems etapas y casi con toda probabilidad va a
producir un error en la salida de nuestro sistema. A la vez que nos vamos
acercando a la salida, un fallo en un registro ms cercano a ella es menos
problemtico.

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).

3.- Si queremos un filtro que sea bastante tolerante a los SEU los ms
importante de redundar son siempre los registros ms cercanos a la entrada,
o sea las primeras etapas del filtro y tambin redundar siempre los bits ms
significantes de las etapas. Ya que haciendo esto, hemos visto que podemos
obtener filtros bastante eficientes y ahorrando gran cantidad de recursos.



Estudio Filtro Fir

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Estudio Filtro Fir

Uploaded by

Copyright:

Available Formats

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

You might also like