Estudio Filtro Fir

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

Jos 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,



- 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:

rp=1; rs=5; fp=5000; fs=6000; fsim=48000; wp=2*fp/fsim; ws=2*fs/fsim; [N,Wn]=buttord (wp,ws,rp,rs);

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

a0 -0.0033

a1 -0.0058

a2 0.0116

a3 0.0969

a4 0.2305

a5 0.2988

a6 0.2305

a7 0.0969

a8 0.0116

a9 -0.0058

a10 -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: Zoom de 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 29) 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

a0 -2 111111110

a1 -2 111111110

a2 6 000000110

a3 50 000110010

a4 118 001110110

a5 154 010011010

a6 118 001110110

a7 50 000110010

a8 6 000000110

a9 -2 111111110

a10 -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:

------------------------------------------------------------------------------------------------- -- Filtro Fir: -- Seal digital de entrada de 18 bits -- Coeficientes de 9 Bits -- Multiplicadores de 18X9 (tantos como coef. se tengan, o sea, tantos como retrasos halla) -- Acumulador (sumador) de dichas multiplicaciones -- Filtro paso de baja tipo Butterworth, con frecuencia de corte de 5 Khz. -- Caso 1: Filtro fir sin redundar -------------------------------------------------------------------------------------------------- -- Bloque para describir los coeficientes del filtro FIR library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; package fir_coef is subtype coef_word is signed(8 downto 0);--coeficientes de 9 bits subtype coef_range is integer range 0 to 10; --numero de coeficientes que hay, o sea, retrasos



type coef_table is array (0 to 10) of coef_word; constant coef_rom: coef_table:= ( ("111111110"), ("111111110"), ("000000110"), ("000110010"), ("001110110"), ("010011010"), ("001110110"), ("000110010"), ("000000110"), ("111111110"), ("111111110")); end package fir_coef; -- Filtro Fir library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.fir_coef.all; entity fir is port (clk,reset,load: in std_logic; data_in: in std_logic_vector(17 downto 0); -- seal digital de entrada de 20 bits data_out: out std_logic_vector(17 downto 0); ultima_etapa: out std_logic_vector(17 downto 0)); end fir; architecture a_fir of fir is type fifo_array is array (0 to 10) of signed (17 downto 0); signal fifo,p_fifo: fifo_array; signal data_outi: std_logic_vector(17 downto 0); component regTmr is Generic(N:integer:=18); Port ( clk : in std_logic; reset : in std_logic; d : in signed (N-1 downto 0);



q : out signed (N-1 downto 0)); end component; component regSimple is Generic(N:integer:=18); Port ( clk : in std_logic; reset : in std_logic; d : in signed (N-1 downto 0); q : out signed (N-1 downto 0)); end component; begin sinc:process (reset,clk) begin if reset = '1' then data_out '0'); elsif clk'event and clk = '1' then data_out 18) port map (clk => clk, reset => reset, d => p_fifo(0), q => fifo(0)); r1: regSimple Generic map (N=>18) port map (clk => clk, reset => reset, d => p_fifo(1), q => fifo(1)); r2: regSimple Generic map (N=>18) port map (clk => clk, reset => reset, d => p_fifo(2), q => fifo(2)); r3: regSimple Generic map (N=>18) port map (clk => clk, reset => reset, d => p_fifo(3), q => fifo(3)); r4: regSimple Generic map (N=>18) port map (clk => clk, reset => reset, d => p_fifo(4), q => fifo(4)); r5: regSimple



Generic map (N=>18) port map (clk => clk, reset => reset, d => p_fifo(5), q => fifo(5)); r6: regSimple Generic map (N=>18) port map (clk => clk, reset => reset, d => p_fifo(6), q => fifo(6)); r7: regSimple Generic map (N=>18) port map (clk => clk, reset => reset, d => p_fifo(7), q => fifo(7)); r8: regSimple Generic map (N=>18) port map (clk => clk, reset => reset, d => p_fifo(8), q => fifo(8)); r9: regSimple Generic map (N=>18) port map (clk => clk, reset => reset, d => p_fifo(9), q => fifo(9)); r10: regSimple Generic map (N=>18) port map (clk => clk, reset => reset, d => p_fifo(10), q => fifo(10)); regs: process(load,fifo,data_in) begin if load = '1' then for i in 1 to 10 loop p_fifo(i)



prod := fifo(i) * coef_rom(i); if (prod(26)='1') then prod:=prod+255; --redondeo end if; idata_tmp := (data_tmp(17)&data_tmp(17)&data_tmp) + (prod(26)&prod(26)&prod(26 downto 9)); 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; end loop; data_outi



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

Documents

Transcript of Estudio Filtro Fir