reporte del filtro iir proc señales

8/17/2019 Reporte Del Filtro IIR Proc Señales

1/6

Procesamiento de Señales

Instituto Tecnológico de Morelia

2/06/15

Alumnos: Marlon Eguía

Carlos Eduardo Aguilera

Profesor: Dr. David Infante

Implementación de un Filtro IIR en Scilab y en microcontrolador.

1.

IntroducciónEn esta práctica se implementó un filtro IIR, que quiere decir infinite impulse response.Podremos entender cómo se realiza mediante software en un programa de manipulación

de matrices como los es el software libre SCILAB así como su implementación en un

microcontrolador.

1.1 Marco teórico

La salida de los filtros IIR depende de las entradas actuales y pasadas, y además de las

salidas en instantes anteriores. Esto se consigue mediante el uso de realimentación de la

salida.

Donde los a y b son los coeficientes del filtro.

2.0 Desarrollo

Como parte de la práctica se pidió elaborar un código en scilab que fuera capaz de aprovechar las

funciones internas del programa mediante el comando hz=iir como se muestra en los siguientes

renglones :

hz=iir(n,ftype,fdesign,frq,delta)

[p,z,g]=iir(n,ftype,fdesign,frq,delta)

Al escribir help y la palabra iir, aparecerá el código de arriba. Se pueden ingresar parámetros como

lo son el orden del filtro, tipo de filtro (Chebyshev, butterworth, bessel, la frecuencia normalizada

que debe ser mayor a cero y como máximo 0.5 que representa ½ de la frecuencia de muestreo

máxima permitida. Esto es muy importante ya que el diseño está en base a la frecuencia de

muestreo.


2/6

En la parte de abajo se muestra el código para el diseño de un filtro pasabajas con frecuencia de

corte de 50 hz y frecuencia de muestreo de 1khz. Al implementar esos comandos obtenemos la

función de transferencia que modela el filtro y podemos hacer un despeje para obtener Vo(k).

clear

clc

fs=1000; //frecuencia de muestreo fc=50;

fcn=fc/fs; //frecuencia de corte normalizada format('v',7)

hz=iir (2,'lp','butt',[fcn],[ ]);[hzm,fr ]=frmag(hz,256);

sal=flts(x,hz);

b=coeff (numer (hz));a=coeff (denom(hz));

Como se menciona en el marco teórico los coeficientes a y b son los que le dan la forma al filtro y

podemos acceder a ellos con el comando coeff como se muestra en el código de la parte superior.

En la figura 1.0 podemos observar la consola del programa al hacer lo que se menciona.

Figura 1.0. Obtención de función de transferencia en el dominio z.

Otra parte del código que se implementó fue la Convolución de una señal ya sea dentro de la

banda de paso (menor a 50 hz) o de una fuera de la banda de paso (mayor a 50 hz) . Como


3/6

sabemos, la Convolución es una multiplicación entre una señal x(t) con una función h(t), aunque el

análisis y resultado se aprecia con mayor enfoque en el dominio de la frecuencia. No obstante, al

hacer esto, la función h(t) es la función de transferencia del filtro IIR con los valores anteriores y

actuales llenándose en un vector Vo cada vez que hay una iteración. Esto se muestra en el código

de abajo.

//x1=Vi

for (i=1:20) if ((i-2)>0)

Vo(i) = 1.561018*Vo(i-1)-0.641351*Vo(i-2)+0.020083*x1(i)+0.040166*x1(i-1)+0.020083*x1(i-2);

else

Vo(i)=0;

end end

subplot(3,2,1)

plot2d(t,Vo)

Si x1 es una señal dentro de la banda de paso, no se atenuará, si esta fuera de la banda de paso, se

atenuará como se puede observar en la figura 1.1 las señales mayores a 50hz comenzaran a ser 0.7

veces la señal de entrada.

Figura 1.1. Comportamiento filtro pasa bajas.

2.1 Implementación del filtro en uc.//--------------------------------------------------------------

//Librerias y definiciones generales

#include

#include

#include

//--------------------------------------------------------------

//--------------------------------------------------------------

//Seccion de inicializacion de variables globalesunsigned int Vo_dac;

//VAriables para hacer las ecuaciones de estado

double Vo_2=0, Vo_1=0, Vo=0 , fracVo ; //Vo

int entVo;

double Vi_2=0,Vi_1=0,Vi=0; //Vi

//-----------------CONSTANTES--------------------------------------------------

const double a= 0.0200833656;


4/6

const double b= 0.0401667311;

const double c= 1.5610180758;

const double d= 0.6413515381;

//-----------------FIN DE CONSTANTES--------------------------------------------

//Programa principal

void main(void)

{

//Seccion de configuracion

WDTCTL = WDTPW + WDTHOLD; // Detiene el Watchdog Timer

BCSCTL1 = CALBC1_1MHZ; // Configura el oscilador interno

DCOCTL = CALDCO_1MHZ; // precalibrado a 16MHz

P1DIR = 0x00;

P2DIR = 0xFF;

P2SEL=0x00; //Desasociamos los perifericos, para utilizar P2.6 y P2.7

P2OUT=0xF0;

CCTL0 = CCIE; // Habilita interrupcion de timer CCR0

CCR0 = 1000; //ts=1ms Valor al que llega el timer TACCR0. SI DCO Y BCS están a 16MHZ entonces CCRO= 1600

//TACTL = TASSEL_2 + MC_1+ID_3; // SMCLK, modo UP y división de 3 1exp 6 /8 =125000

TACTL = TASSEL_2 + MC_1;

ADC10CTL1 = INCH_0; // Canal de entrada A0

ADC10CTL0 = ADC10ON; // Enciende ADC

ADC10AE0 |= 0x01; // P1.0 como periferico A0

_BIS_SR(GIE); // Activa las interrupciones globales del mC

//Ciclo Principal

while (1) // ciclo infinito que no hace nada

{

}

}

//--------------------------------------------------------------

//--------------------------------------------------------------

//Seccion de vectores de interrupcion

// Timer A0 interrupt service routine

#pragma vector=TIMER0_A0_VECTOR

__interrupt void Timer_A (void)

{

//--------------ENCENDIDO DEL ADC Y TOMA MUESTRAS-----------------------------

ADC10CTL0 |= ENC + ADC10SC; //Habilita convesion e inicia conversion

while (ADC10CTL1 & ADC10BUSY); //Espera a que termine de hacer la conversion

Vi=ADC10MEM;//---------------------- Asignacion de Vi-------

ADC10CTL0 &= ~ENC;

Un problema muy importante que se

presentó fue aquí ya que al estar

configurado a 1Mhz las cuentas dentro

de la interrupción no se ejecutaban en

1ms, tardaban 2ms y esto se veía en el

osciloscopio en los escalones de la

señal de salida. El aumentar a 16 Mhz

hace que las operaciones máquina

/ciclos máquina se ejecuten más rápido

y al cambiar de 1Mhz en las líneas

rojos, hizo que funcionara

correctamente.


5/6

//-------------APAGADO DE ADC Y CALCULAR Vo-----------------------------------

// P2OUT^=0x01;///*

Vo= a*(Vi_2)+b*(Vi_1)+a*(Vi)+c*(Vo_1)- (d*(Vo_2));//Ecuación de salida

entVo=(int)Vo;

Vo_dac=entVo>>2; //Como la salida es de 8 bits se hace un corrimiento porque ADC es de 10 bitsP2OUT=Vo_dac; //Mostrar valor de la salida

Vo_2=Vo_1;

Vi_2=Vi_1;

Vo_1=Vo;

Vi_1=Vi;

//---------------Asignación de valores de Vi----------------------------------

//*/

} //FIN DE LA INTERRUPCION

2.2 Hardware y conexiones

Se utilizó un MSP430G2553, un DAC0832 para hacer la práctica como se muestra en la figura 1.3.

Figura 1.3. Diagrama de conexión al microcontrolador y al DAC0832.

J3

uc_lef t

12345678910

P2.3

J4

uc_right

12345678910

P1.0

P1.2P1.1

P1.3

P2.2

P1.4P1.5P2.0P2.1

P2.1

P2.2

P2.6P2.7

P2.0

TESTRESETP1.7P1.6P2.5P2.4P2.3

P2.4P2.5P2.6

5v

P2.7

VCC_3.3

12v

Conexion al uc

5v

5v

12v

12v

-12v-12v

RFBIOUT1

U3A

LM324

+3

-2

V+4

V -

1 1

OUT 1

U3B

LM324

+5

-6

V+4

V -

1 1

OUT 7

IOUT1

R1

10k

R2

10k

J12

CON1

1

D1

LED

R3

1k

J10

CON3

123

12v

J8

Vref

1-12v

J11

CON5

12

345

U2

DAC0832

CS1

WR12

GND3

DI34

DI25

DI16

DI07

VREF8

RFB9

GND210

IOUT1 11IOUT2 12DI7 13DI6 14DI5 15DI4 16XFER 17WR2 18ILE 19VCC 20


6/6

En la figura 1.4 se observa en físico el hardware y como se conecta donde ya se tiene un PCB con el

DAC.

}

Figura 1.4. MSP launchpad y DAC.

3. Conclusiones y Resultados

Al final se obtuvo lo esperado. La señal de entrada que le metimos al uc fue de 1v a una frecuencia

de 50 hz. En la salida lo que veíamos era esa señal pero con una amplitud de 0.7 cumpliendo el

comportamiento del filtro. También se pudieron observar los escalones de 1ms en la señal de

salida, algo que no pasaba cuando se tenía el DCO a 1Mhz , ya que ahí los escalones eran de 2ms y

no concordaba ya que la interrupción se ejecuta cada 1 ms.

Se concluye que los filtros IIR usan operaciones de punto flotante y recursivos que pueden hacer

que las cuentas tarden mucho, por lo tanto es recomendable manejarse a la mayor velocidad

posible dentro del microcontrolador y es por esto que se usan DSPs para implementar filtros ya

más robustos.

Fue indispensable realizar el diseño mediante scilab ya que ahorra muchas cuentas a mano y se

pueden apreciar las respuestas a las señales sin necesidad de conectar circuitos y así estar mejor

preparado cuando se requieran solucionar problemas como el que se tuvo del reloj interno y se

descarten errores de diseño.

Otro problema que se tenía era que la señal de salida era mayor cuando el DAC era conectado a 5

v, y eso estaba mal ya que se debe hacer a 3.3v que es el rango de voltajes de entrada que maneja

el uc y ocupa estar al mismo voltaje de referencia el DAC. Al hacer esto ya no hubo problemas.

reporte del filtro iir proc señales

Documents