Estudio filtro firbibing.us.es/proyectos/abreproy/11375/fichero/MEMORIA... · ESTUDIO DEL FILTRO FIR EN PRESENCIA DE S.E.U. 37 José Manuel Marín de la Rosa Una vez que sabemos el

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

José Manuel Marín de la Rosa

ESTUDIO DEL FILTRO FIR

EN PRESENCIA DE S.E.U.

3.1. INTRODUCCIÓN

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

parámetros:

- Frecuencia de paso: fp = 5 Khz,

- Frecuencia de corte: fs = 6 Khz.,

- Atenuación en la banda de paso: rp = 1 dB,



- Atenuación 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 después estudiar su sensibilidad en presencia de SEU (Single Event

Upset). Para implementarlo tendremos que saber sus coeficientes ya que

como vimos en el apartado teórico, 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 descripción

hardware (VHDL) en el que sólo tendremos que generar los sumadores,

multiplicadores y los retrasos (estos se harán 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 “teórico” realizado en MATLAB, y comprobando que ambos filtros

responde idénticamente (o al menos parecido) ante los mismos estímulos

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 realizándole 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. CARACTERIZACIÓN 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 aproximación de butterworth y

escribiendo la siguiente función 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 parámetros a la

función 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 aproximación en

concreta, solo nos falta por saber los coeficientes del filtro FIR, para ello

usamos la función de MATLAB “fir2”, a la cual se le pasa como

parámetros 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 parámetro, dentro de la

variable a2(z) los coeficientes de la tabla 1.

Para probarlo, le hemos metido 2 señales de entrada, un seno de gran

amplitud a una frecuencia de 3.980 Hz y una señal de ruido de gran

potencia, y comprobamos que a la salida se “filtra” la señal sinusoidal

limpiándola 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 señales a la vez. La

entrada (señal sinusoidal más ruido) es la señal amarilla, y la señal de

salida, la filtrada (que debe de ser solo la sinusoidal) es la señal 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 señal de salida del filtro

Y en ella se ve claramente como el filtro funciona bien, y a la salida

tenemos solamente la señal sinusoidal (discretizada claro está al tratarse de

un filtro discreto) y hemos conseguido quitar el ruido.

Si hacemos un análisis 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 señal de salida en el tiempo, la

densidad espectral de potencia y la fase. Como cabía de esperar tenemos

una sampling centrada a la frecuencia del seno (3.980 hz).



Figura 16: Análisis espectral de la salida del filtro

Si cambiamos el seno de entrada por otro seno de frecuencia 10 Khz.

a la salida se tendría 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 análisis espectral de la salida con una entrada de un seno de 10

Khz. más una componente de ruido es el siguiente:

Figura 18: Análisis espectral de la salida con entrada de 10 Khz.

En el que se observa claramente en la señal 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 señal 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. IMPLEMENTACIÓN 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 programación 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 teóricos, se trata de la estrutura

directa I. En el dibujo, solo se han representado 8 etapas, pero sabemos que

nuestro diseño debe de tener 11 etapas, siguiendo la estructura de la figura

19, que es fácil de implementar.

Para nuestro diseño, hemos decidido, que la señal digital que entra en

el filtro (X(n)) provenga de digitalizar la señal analógica con 18 bits, así

que las muestras de la señal de entrada estarán codificadas con 18 bits, ya



que así logramos tener una buena precisión. 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 más

cercano (redondeamos por arriba si el número es positivo y por abajo si el

número es negativo) obtenemos la siguiente tabla:

Coeficiente Valor Codificación 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 señales X(n-L) son multiplicadas por los coeficientes

correspondientes h(L), para implementar dicha multiplicación, 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, según el resultado sea un

número positivo o un número 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 código en VHDL, queda de la

siguiente manera:

------------------------------------------------------------------------------------------------- -- Filtro Fir: -- Señal 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); -- señal 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 <= (others => '0'); elsif clk'event and clk = '1' then data_out <= data_outi; end if; end process sinc; r0: regSimple Generic map (N=>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) <= fifo(i-1); end loop; p_fifo (0) <= signed (data_in); else for i in 0 to 10 loop p_fifo(i) <= fifo(i); end loop; end if; end process regs; firstruct: process (fifo) variable prod: signed (26 downto 0); variable idata_tmp: signed (19 downto 0); variable data_tmp: signed (17 downto 0); begin data_tmp := (others => '0'); for i in 0 to 10 loop



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 <= std_logic_vector (data_tmp); end process firstruct; ultima_etapa <= (others =>'0'); end a_fir; Este código, junto con la descripción de los componentes, y los

sucesivos códigos que debemos de generar para realizar las pruebas

oportunas se adjuntan al final de la documentación 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 “teórico” que caracterizamos en MATLAB, para ello, a los dos le

vamos a meter la misma entrada, y por lo tanto deberíamos 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 señal de entrada la

hacemos pasar por un cuantizador para cuantizarla, después 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

código VHDL oportuno, se le pase dicho fichero como parámetro 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 expondrán

en el anexo) podemos ver los resultados.

El contenido de la variable “Entrada1”,que se obtuvo haciendo la

simulación 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 prácticamente

idénticas, los errores que se tienen son errores difíciles 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

propósito de ésta investigación, que no es otro sino que estudiar el

comportamiento de filtros en presencia de SEU.

Vamos a comenzar estudiando el filtro FIR, para después, hacer lo

propio con un filtro IIR y así poder comparar los resultados obtenidos.

Como sabemos, cuando un circuito electrónico se encuentra en

presencia de SEU, éste puede hacer que varíe algunas de las propiedades

físicas 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 daría sin introducir fallos con la salida

que se obtiene introduciendo estos fallos “voluntariamente”.

Para introducir estos “errores” vamos a hacer uso de una herramienta

diseñada en la Universidad de Sevilla por AICIA-GTE, ESA en un proyecto

denominado “FT-UNSHADES” más en concreto de las publicaciones:

“FT-UNSHADES Design Preparation Tools” y “FT-UNSHADES

Design Test and Analysis Tools” cuya documentación 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 metiéndole 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 dónde) produce fallo. Los fallos

que se meten en la copia del diseño, se introducirán muchas veces en

distintos tiempos, por eso algunas veces introducir un error en un registro

en concreto de nuestro diseño puede dar fallos o no, dependiendo de el

ciclo de reloj en el que se encuentre.

Con ésta información 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á crítico para nuestro filtro, ya que un fallo en ese bit puede que siempre

produzca un fallo en la salida.

Esa será nuestra primera misión, después, una vez realizado eso

vamos a introducir triple redundancia modular en nuestro filtro y elección

por mayoría, o sea, replicar nuestro diseño tres veces y elegir la salida

mediante “votación” de los tres. Veremos que si redundamos todos los

registros de nuestro filtro, aunque se produzcan fallos dentro de algún

registro, nunca se tendrá error a la salida, o sea, esto sería lo ideal, ya que

tendríamos un 0% de fallos a la salida en presencia de SEU, pero claro está



también es la solución 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 módulos, 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 códigos están 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 realización 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 críticas como pueden ser sistemas para proyectos espaciales,

circuitos electrónicos de láser para operaciones oculares (imaginad por un

instante que ese láser falla por un momento, sería un desastre para la

operación y podría dejar ciega de por vida a la persona en cuestión), etc,….

Está claro que para estas aplicaciones no se repara en recursos y se

redundaría el sistema un 100% para evitar desastres.

Sin embargo, hay otras muchas aplicaciones, como por ejemplo

contadores de surtidor de gasolina, circuitos de electrodomésticos, y de

propósito general, en los que no se requieren un 100% de eficiencia, son

en estos circuitos en los que se busca una mejor relación 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 más fallos, y estudiar la mejor

relación eficiencia-precio de nuestro sistema. Las pruebas consisten en

introducir 10.000 errores en distintos lugares y en distintos momentos en

nuestro diseño 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 protección, 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 más críticos cuanto más cerca

de la entrada se produce, o sea, que los registros más críticos son los las

cercanos a la entrada, el registro0, el registro1, el registro2… y así

sucesivamente, y dentro de los registros son mucho mas críticos 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 demás si.


error en los bits 0, 1, 2 y 3. Si se introduce en los demás si.


error en los bits que van del 0 al 6, en los demás 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 demás sí.

En conclusión, los bits mas significativos son críticos!, 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 más críticos que los que están

mas cercanos a la salida. (Código VHDL en anexos)

PRUEBA 2: La siguiente prueba que hicimos fue redundando todo el

sistema. Como cabría de esperar tuvimos un 100 % de eficiencia por eso no

anexo el fichero de salida de esta prueba, ya que es obvio como sería.

- Recursos utilizados: 612 flip-flops,

- Eficiencia: 100%

Como se observa, se tiene 3 veces mas de recursos que en el caso

anterior. (Código 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 más 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 (código en Anexos) y la

analizamos, obteniendo los siguientes resultados:

- Recursos utilizados: 502 flip-flops

- Eficiencia 93.56%

Como vemos, hemos conseguido quitar un número 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 cabría esperar, que los

fallos se tienen en los bits más significativos de cada registro, que son los

que no están redundados. Y como en esos bits eran en los que menos fallos

se tenían sin redundar por esa razón 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 más 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 (según para la aplicación 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 más 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 más o menos se esperaba por dos

motivos:

1.- Hay mas registros pares que impares, si se redundan los pares, se

redundan más 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 sólo 396. Así que si se tiene más redundancia, claro está que

se tendrá mejores resultados.

2.- El segundo motivo es porque como vimos en la prueba 1, los

registros que están más cerca de la entrada son más importantes y más

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 además también

redundamos el registro 0 totalmente. Eso es lo que haremos en la siguiente

prueba.

PRUEBA 9: Redundamos todos los registros impares y además el registro

0, y los demás 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 número de flip-flops en

las dos. Pues bien, se observa que por muy poco, apenas el 3% es mejor

redundar los impares (más el registro 0) que los pares (más el registro 0).

Esto también puede tener una explicación, y es que, como dijimos en la

prueba 1, los registros más sensibles son los más cercanos a la entrada, si

en las dos pruebas tenemos redundado el registro 0 que es el más 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 más útil redundar, si los 9 bits

más 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 más

significativos de todos los registros dejando si redundar los 9 LSB,

y después 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 más 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 más importante redundar los bits

más 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 más sensibles, o sea con mayor porcentaje de que al

introducir en ellos un fallo se tenga un error en la salida, son los registros

más 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 demás 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 más cercano a ella es menos

problemático.

2.- Los bits más 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 más significativos (los MSB).

3.- Si queremos un filtro que sea bastante tolerante a los SEU los más

importante de redundar son siempre los registros más cercanos a la entrada,

o sea las primeras etapas del filtro y también redundar siempre los bits más

significantes de las etapas. Ya que haciendo esto, hemos visto que podemos

obtener filtros bastante eficientes y ahorrando gran cantidad de recursos.



Documents

Estudio filtro firbibing.us.es/proyectos/abreproy/11375/fichero/MEMORIA... · ESTUDIO DEL FILTRO FIR EN PRESENCIA DE S.E.U. 37 José Manuel Marín de la Rosa Una vez que sabemos el