Filtros adaptativos Implementación en DSP

Slides:

Advertisements

Presentaciones similares

Comunicaciones Móviles: Sistemas de Tercera Generación

Advertisements

Laboratorio virtual de Control por Computador

Procesadores digitales de señal (PDS)

CAP. 6 - DISTORSIÓN Ing. Verónica M.Miró 2011.

RUIDO RUIDO BLANCO.

ESCUELA SUPERIOR POLITÉCNICA DEL LITORAL

Introducción a los Procesadores Digitales de Señal (DSP)

Validación de Hardware

IAR134 Procesamiento de Señales

ESCUELA POLITÉCNICA DEL EJÉRCITO CARRERA DE INGENIERÍA EN ELECTRÓNICA Y TELECOMUNICACIONES ANÁLISIS DE FILTROS ADAPTATIVOS DE LA FAMILIA SM APLICADOS.

Tramitar todos los tipos de operación realizados en Ventanilla Única

EL ALGORITMO ADAPTATIVO MINIMO CUADRADO RECURSIVO RLS

Control PID A que nos referimos con control? Quiero mantener la salida constante, pero la salida depende del entorno - puede aparecer torque variable sobre.

Ecualizadores digitales

APRENDIZAJE WIDROW- HOFF

El Perceptrón  El psicólogo Frank Ronsenblant desarrolló un modelo simple de neurona basado en el modelo de McCulloch y Pitts que utilizaba.

Juan Andrés Negreira 22 de febrero de 2007

2. DISEÑO DE SEÑALES Y FILTROS

Anterior La tablilla principal controla todas las conexiones para los diferentes dispositivos de entrada y salida, es también la que tiene los chips para.

Como empezar en Access 2000 Abrir Access 2000 Pulsamos INICIO

Redes Neuronales Monocapa

INTRODUCCIÓN A LA IDENTIFICACIÓN DE SISTEMAS

ADALINE — The Adaptive Linear Element

Grupo de investigación Applied Signal Processing Departamento de Teoría de la Señal y Comunicaciones Escuela Politécnica Superior Universidad de Alcalá.

Procesamiento digital Parte 3 - Filtros

Aspectos Generales de IPD-414 IPD 414 – Seminario de Procesamiento Digital de Señales Segundo semestre Matías Zañartu, Ph.D. Departamento de Electrónica.

Distorsión por retardo

EL ALGORITMO ADAPTATIVO DE MODULO CONSTANTE CMA

Electrónica aplicada al tratamiento de datos Procesadores digitales de señal (PDS) DSP: Digital Signal Processors (procesadores) DSP: Digital.

Desarrollo de un sistema de identificación de procesos industriales en línea, usando la plataforma open-source Arduino y Matlab/Simulink Departamento de.

ESCUELA SUPERIOR POLITECNICA DEL LITORAL FIEC

Procesadores digitales de señal (PDS)

Adaptive Coded Modulation System Model. El problema  Usuarios de servicios inalámbricos requieren altas tasas de transferencia de datos.  Requerimientos.

Redes de Computadores I Agustín J. González

CODIGO GRAY Hasta la primera mitad de los años 1940 los circuitos lógicos digitales se realizaban con válvulas de vacío y dispositivos electromecánicos.años.

Modos deslizantes de orden superior

UNIVERSIDAD COOPERATIVA DE COLOMBIA FACULTAD DE INGENIERIA ELECTRONICA

En este bloque aprendimos como en office Word marcar entradas de índice y crear un índice, aplicar un formato a una entrada de índice. En Excel creamos.

Tema 3: Filtros.

Estabilidad en Frecuencia

Procesamiento de Señales y Comunicaciones Algunos temas de Trabajo DIEC – UNS.

Presentado por: JUAN FRANCISCO ALVAREZ ALVARADO

Previo a la obtención del Título de:

TEMA 2 CARACTERIZACIÓN FRECUENCIAL DE SEÑALES Y SISTEMAS

Aspectos Generales de ELO-313 ELO 313 –Procesamiento Digital de Señales con Aplicaciones Primer semestre – 2015 Matías Zañartu, Ph.D. Departamento de Electrónica.

Una Estructura en Cascada para Prediccion Lineal Adaptiva Presentado por: Guillermo Dalla Vecchia ) Martes 14 de Setiembre, 2003.

8.4 Toolbox de Matlab.

Configuramos el programa editor. Audacity Inserta el micrófono en la tarjeta de sonido.

Agenda Introducción Señales de Voz Sistema Monoacústico Sistema Estéreo Sistema Híbrido Mono/Estéreo Detectores de doble Conversación.

Fue inventada por Phillip Smith en 1939 mientras trabajaba para RCA. El motivo que tenía Smith para hacer este diagrama era representar gráficamente las.

Filtros Adaptativos en FPGA

Utilización de la Carta de Smith

EduCat Prototipos. Introducción En las próximas páginas se muestra un bosquejo de lo que será la interfaz gráfica de nuestro programa, EduCat, para los.

CLASIFICACION DE SEÑALES

Ciclo de desarrollo del software

BANCOS DE PRUEBAS CON VHDL (TESTBENCHES). Sistemas Digitales - FIUBA Bancos de prueba ¿Cómo realizar la prueba de un dispositivo descripto en VHDL? DUT.

Diseño, implementación y verificación de un sistema de hardware reconfigurable para aplicaciones de control. de un sistema de hardware reconfigurable para.

DETECCION DE SEÑALES BINARIAS EN RUIDO GAUSSIANO El criterio de toma de decisión fue descrito por la ecuación Un criterio muy usado para escoger el nivel.

HARDWARE – SOFTWARE - MANTENIMIENTO Presentado por: Andrey Muñoz Dayana Cubillos Sandra Hernández.

LABORATORIO VIRTUAL DE TVAD de RTVV GABINETE I+D+i.

OPTIMIZACION DEL DESEMPEÑO DE ERROR

Dr. Rogerio Enriquez Caldera

Programa de Simulación

Lección 1 Introducción. Ventanas de Inicio Clic.

Red Adaline B. Widrow & M. Hoff (Adaptive Linear Element)

4. Métodos psicofísicos de medida en clínica

Curso de programación Visual Chart 6 (1ªEd.) MAS EJEMPLOS. PARTE 2.

BANCOS DE PRUEBA CON VHDL (TESTBENCHES). Sistemas Digitales - FIUBA Bancos de prueba ¿Cómo realizar la prueba de un dispositivo descripto en VHDL? DUT.

Ecuación de la grafica: y = 6 – 2x y = 6 – 2x y = 6 – 2(0) y = 6 ( x, y ) ( 0, 6 ) xy

Aspectos Generales de ELO-313 ELO 313 –Procesamiento Digital de Señales con Aplicaciones Primer semestre – 2016 Matías Zañartu, Ph.D. Departamento de.

Transcripción de la presentación:

Filtros adaptativos Implementación en DSP Laboratorio DSP y FPGA ITBA 2010

Algoritmo LMS

Algoritmo LMS Salida del filtro: Error en la estimación: Adaptación de los coeficientes: Valores anteriores de la entrada: Coeficientes del filtro:

Posibles aplicaciones System identification / modelado adaptativo Cancelación de ruido Ecualización adaptativa Control de eco Beamforming …

Ejemplo: system identification Filtro adaptativo Sistema desconocido - +

Simulación en MATLAB Inventamos un sistema desconocido Hacemos pasar ruido blanco por el sistema desconocido Adaptamos el filtro muestra a muestra Graficamos el error en el tiempo Ver simulación

Ejemplo con DSP56002 Sistema desconocido + Filtro adaptativo - OUT L OUT R IN L RUIDO BLANCO + -

Algoritmo LMS move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 Adaptación de los coeficientes:

Algoritmo LMS X Y r0 r4 r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 x(n-1) w1(n) x(n-2) w2(n) x(n-3) w3(n) x1: x0: y0: a:

Algoritmo LMS X Y r0 r4 r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 x(n-1) w1(n) x(n-2) w2(n) x(n-3) w3(n) x1: e(n) x0: y0: a:

Algoritmo LMS X Y r0 r4 r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 x(n-1) w1(n) x(n-2) w2(n) x(n-3) w3(n) x1: e(n) x0: mu y0: a:

Algoritmo LMS X Y r0 r4 r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 x(n-1) w1(n) x(n-2) w2(n) x(n-3) w3(n) x1: e(n) x0: mu y0: a: e(n).mu

Algoritmo LMS X Y r0 r4 r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 x(n-1) w1(n) x(n-2) w2(n) x(n-3) w3(n) x1: e(n).mu x0: mu y0: a: e(n).mu

Algoritmo LMS X Y r0 r4 r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 x(n-1) w1(n) x(n-2) w2(n) x(n-3) w3(n) x1: e(n).mu x0: x(n) y0: a: w0(n)

Algoritmo LMS X Y r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 r0 r4 x(n-1) w1(n) x(n-2) w2(n) x(n-3) w3(n) x1: e(n).mu x0: x(n) y0: a: w0(n)

Algoritmo LMS X Y r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 r0 r4 x(n-1) w1(n) x(n-2) w2(n) x(n-3) w3(n) x1: e(n).mu x0: x(n) y0: a: w0(n)+mu.x(n).e(n)

Algoritmo LMS X Y r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 r4 x(n-1) w1(n) r0 x(n-2) w2(n) x(n-3) w3(n) x1: e(n).mu x0: x(n-1) y0: a: w0(n)+mu.x(n).e(n)

Algoritmo LMS X Y r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 x(n-1) w1(n) r0 r4 x(n-2) w2(n) x(n-3) w3(n) x1: e(n).mu x0: x(n-1) y0: w1(n) a: w0(n)+mu.x(n).e(n)

Algoritmo LMS X Y r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n+1) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 x(n-1) w1(n) r0 r4 x(n-2) w2(n) x(n-3) w3(n) x1: e(n).mu x0: x(n-1) y0: w1(n) a: w0(n)+mu.x(n).e(n)

Algoritmo LMS X Y move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 x(n) w0(n+1) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 r5 x(n-1) w1(n) r0 r4 x(n-2) w2(n) x(n-3) w3(n) x1: e(n).mu x0: x(n-1) y0: w1(n) a: w0(n)+mu.x(n).e(n)

Algoritmo LMS X Y move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 x(n) w0(n+1) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 r5 x(n-1) w1(n) r0 r4 x(n-2) w2(n) x(n-3) w3(n) x1: e(n).mu x0: x(n-1) y0: w1(n) a: w1(n)

Algoritmo LMS X Y move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 x(n) w0(n+1) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 r5 x(n-1) w1(n) r0 r4 x(n-2) w2(n) x(n-3) w3(n) x1: e(n).mu x0: x(n-1) y0: w1(n) a: w1(n)

Algoritmo LMS X Y move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 x(n) w0(n+1) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 r5 x(n-1) w1(n) x(n-2) w2(n) r0 r4 x(n-3) w3(n) x1: e(n).mu x0: x(n-2) y0: w2(n) a: w1(n)+mu.x(n-1).e(n)

Algoritmo LMS X Y move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 x(n) w0(n+1) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 x(n-1) w1(n+1) r5 x(n-2) w2(n) r0 r4 x(n-3) w3(n) x1: e(n).mu x0: x(n-2) y0: w2(n) a: w2(n)

Algoritmo LMS X Y r0 r4 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n+1) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 x(n-1) w1(n+1) r5 x(n-2) w2(n) x(n-3) w3(n) x1: e(n).mu x0: x(n-3) y0: w3(n) a: w2(n)+mu.x(n-2).e(n)

Algoritmo LMS X Y r0 r4 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n+1) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 x(n-1) w1(n+1) x(n-2) w2(n+1) r5 x(n-3) w3(n) x1: e(n).mu x0: x(n-3) y0: w3(n) a: w3(n)

Algoritmo LMS X Y move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 x(n) w0(n+1) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 r0 r4 x(n-1) w1(n+1) x(n-2) w2(n+1) r5 x(n-3) w3(n) x1: e(n).mu x0: x(n) y0: w0(n+1) a: w3(n)+mu.x(n-3).e(n)

Algoritmo LMS X Y r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n+1) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 r0 r4 x(n-1) w1(n+1) x(n-2) w2(n+1) x(n-3) w3(n+1) x1: e(n).mu x0: x(n) y0: w0(n+1) a: w0(n+1)

Algoritmo LMS X Y r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n+1) move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 r0 r4 x(n-1) w1(n+1) x(n-2) w2(n+1) x(n-3) w3(n+1) x1: e(n).mu x0: x(n) y0: w0(n+1) a: w0(n+1) Quedaron actualizados todos los coeficientes w

Algoritmo LMS X Y r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) w0(n+1) r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 r4 x(n-1) w1(n+1) x(n-2) w2(n+1) r0 x(n-3) w3(n+1) x1: e(n).mu x0: x(n-1) y0: w0(n+1) a: w0(n+1) NOTA: n0 = -2

Algoritmo LMS X Y r4 r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) r4 w0(n+1) r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 x(n-1) w1(n+1) x(n-2) w2(n+1) r0 x(n-3) w3(n+1) x1: e(n).mu x0: x(n-1) y0: w1(n+1) a: w0(n+1)

Algoritmo LMS X Y r4 r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a x(n) r4 w0(n+1) r5 move X:ErrorN,x1 move #mu,x0 mpy x0,x1,a move a,x1 move x:(r0)+,x0 y:(r4)+,a do #ntaps,_coefupdate macr x0,x1,a x:(r0)+,x0 y:(r4)+,y0 tfr y0,a a,y:(r5)+ _coefupdate move x:(r0)+n0,x0 y:(r4)-,y0 x(n-1) w1(n+1) x(n-2) w2(n+1) r0 x(n-3) w3(n+1) x1: e(n).mu x0: x(n-1) y0: w1(n+1) a: w0(n+1) La próxima muestra x(n+1) pisa a x(n-3)

Salida del filtro Salida del filtro: move X:EntradaN,x0 clr a x0,x:(r0)+ y:(r4)+,y0 rep #ntaps-1 mac x0,y0,a x:(r0)+,x0 y:(r4)+,y0 macr x0,y0,a Este es el algoritmo del FIR

Código assembler Código canal derecho y canal izquierdo Generación de ruido blanco Problema con saturación por nivel del ruido Problema con delay / Línea de retardo

Pruebas Simulación Pruebas con loop cerrado (cable) Ver señal de error en el osciloscopio Modificar mu y verificar convergencia Pruebas con parlante y micrófono

Trabajo práctico Parte A) Algoritmo NLMS En LMS convergencia y estabilidad dependen de mu Efecto de la potencia de x(n) Normalización con la potencia de la señal

Trabajo práctico ? Parte B) Cancelación adaptativa de ruido Se desea eliminar la interferencia (N) presente en una señal (S + N). Se cuenta con una señal de referencia (N´) que está correlacionada (en forma desconocida) con el ruido que contamina la señal de interés (S). S + N N’ S ?

Algoritmo LMS - origen Según el método de steepest-descent Usamos los estimadores instantáneos:

Referencias Farhang, Boroujeny. Adaptive filters – Theory and applications. Haykin. Adaptive filter theory. Widrow, Stearns. Adaptive signal processing.