SISTEMAS ELECTRNICOS DIGITALES Problema 2 (40%) Septiembre 2006 Apellidos, Nombre: .

Se desea programar un filtro digital con el 68hc11 con el objetivo de filtrar una seal analgica que entra por el pin PE7. El filtro digital responde a la expresin:

y(n)=

1281 [16.y(n-1) - 67.y(n-2) + 16. y(n-3) + 20. x(n) + 61.x(n-1) + 61.x(n-2) + 20.x(n-3) ]

Todos los trminos que aparecen son de 8 bits sin signo (positivos). El trmino x(n) es el nuevo dato que ha convertido el CAD. Los trminos x(n-1), x(n-2) y x(n-3) son los valores anteriores de x(n). Cada vez que se obtiene un nuevo valor de x(n) se aplica la expresin anterior para obtener el valor de la seal filtrada en el instante actual, y(n). Los trminos y(n-1), y(n-2) e y(n-3) son los valores anteriores de y(n). Esta expresin se ha obtenido redondeando los coeficientes que nos proporciona el programa Matlab para un filtro con las siguientes especificaciones:

Filtro de Chebyshev. Frecuencia de muestreo (fm): 4 khz. Frecuencia de pasabanda (fp): 1 Khz. Rizado en la banda pasante: 0,5db. Orden 3.

|H(f)|

ffp

1

2

fs

Pasabanda

Parabanda

Banda de transicin

El valor digital de salida del filtro se enviar al puerto B que estar conectado a un convertidor digital-analgico que permite reconstruir la seal analgica de entrada pero atenuando aquellas frecuencias que superan el valor de la frecuencia de pasabanda (fp). Se pide:

1. Variables necesarias para el problema. Escribir el ensamblador de la declaracin de las variables. [1 punto].

2. Ensamblador de la rutina Filtro que calcular el nuevo valor de y(n) a partir de

x(n) segn la expresin arriba indicada. Esta rutina utilizar como parmetro de entrada el acumulador A que contendr el nuevo valor de x(n). Aquellas consideraciones que se consideren oportunas se detellarn bien al principio o al final del ensamblador. Tambin se evaluarn los comentarios. [4 puntos].

Nota: Las instrucciones de sumar/restar consideran a los operandos con signo y las instrucciones de multiplicar/dividir consideran a los operandos sin signo. Adems, el resultado de multiplicar es de tamao 2 bytes.

3. Ensamblador de las constantes del programa. [1 punto].

4. Ensamblador del mdulo inicial con comentarios. [1 punto].

5. Ensamblador del resto del programa con comentarios. [3 puntos].

SOLUCIN

1. Variables que se utilizarn para implementar el filtro.

Se utilizarn dos variables: yn e xn. Ambas sern dos vectores de 4 bytes que almecenarn los valores actuales y anteriores de la salida (y(n), y(n-1), y(n-2), y(n-3)) y de la entrada (x(n), x(n-1), x(n-2), x(n-3)). Tambin se utilizarn 2 variables auxiliares de 2 bytes: aux y result. La declaracin en ensamblador de las variables es la siguiente:

ORG $0000 yn RMB 4 xn RMB 4 result RMB 2 * Acumula el resultado aux RMB 2 * Auxiliar para las restas

Los coeficientes son valores constantes que se declararn como vectores fijos al final de las instrucciones. Se distinguirn entre los coeficientes de las entradas cx y de las salidas cy pero sin signo. El ensamblador de estos dos vectores sera el siguiente:

cx FCB 20,61,61,20 cy FCB 128,16,67,16

2. Ensamblador de la rutina Filtro que calcula y(n) a partir de x(n).

La salida digital del convertidor ser un nmero positivo en el rango que va de 0 a 255. Este nmero ser proporcional a la tensin de entrada analgica cuyo rango habitual es de 0V a 5V. La expresin del filtro consta de multiplicaciones, sumas y restas segn se tiene del enunciado:

y(n)= 128

1 (16.y(n-1) - 67.y(n-2) + 16. y(n-3) + 20. x(n) + 61.x(n-1) + 61.x(n-2) + 20.x(n-3) )

Las instrucciones del ensamblador del 68hc11 tienen las siguientes limitaciones: Las pocas instrucciones aritmticas del 68hc11 solo permiten trabajar con nmeros

enteros. Las instrucciones ADDD y SUBD permiten sumar/restar el contenido del doble

acumulador D con una variable de memoria de 2 bytes. Las dos instrucciones consideran que los operandos tienen signo1.

La instruccin MUL multiplica el contenido sin signo del acumulador A (8 bits) por el contenido sin signo del acumulador B (8 bits). El resultado lo devuelve en el aumulador D (2 bytes) sin signo. Hay que tener cuidado al utilizarla ya que si el resultado es un nmero positivo muy grande entonces el bit ms significativo estar a 1. En cualquier suma o resta posterior ser considerado como un nmero negativo. En nuestro ejercicio no est presente ese problema ya que los coeficientes se ajustarn para que los productos no generen nmeros muy grandes que activen este bit que puede dar lugar a errores.

1 Los operandos se almacenan internamente en complemento a 2. Por tanto el bit ms significativo de los 16 que tiene se considera como el bit de signo. Si este bit est a 1 lgico el nmero almacenado es negativo.

Se utilizar la variable result (2 bytes) para ir acumulando las sumas y restas que se vaya ejecutando. Solo hay una resta que nos obliga a apoyarnos en una variable auxiliar que se ha llamado aux.

El resultado de las sumas y restas habra que dividirlo entre 1282. En la siguiente figura

se muestra el acumulador D antes de dividirlo entre 128. Tambin se tiene en cuenta que el acumulador A son los 8 bits ms significativos del acumulador D y que el acumulador B son los 8 bits menos significativos de dicho registro.

0

Acumulador A Acumulador B

d d d d d d d dd d d d d d d

Acumulador D

El bit ms significativo es el bit de signo y estar a 0 ya que el resultado final y(n) debe ser positivo (es un valor prximo a x(n)). Al realizar 7 desplazamientos a la derecha se obtendra el resultado (8 bits sombreados) en el acumulador B. Sin embargo, es ms eficiente realizar un nico desplazamiento a la izquierda del acumulador D y se tendra el resultado en el acumulador A. As es como se implementar en ensamblador.

La rutina Filtro realiza los siguientes pasos:

1. Se actualizan las variables de las entradas:

- x(n-3) = x(n-2) - x(n-2) = x(n-1) - x(n-1) = x(n) - x(n) = A

2. Se actualizan las variables de las salidas:

- y(n-3) = y(n-2) - y(n-2) = y(n-1) - y(n-1) = y(n)

3. Se calcula el nuevo valor de y(n) segn la frmula

y(n)= 128

1 (16.y(n-1) - 67.y(n-2) + 16. y(n-3) + 20. x(n) + 61.x(n-1) + 61.x(n-2) + 20.x(n-3) )

4. Se enva el nuevo valor filtrado al puerto B para que lo reciba el CDA

PORTB= y(n) 5. Salir

2 El nmero 128 es potencia de 2 (27).La divisin se programar como 7 desplazamientos del acumulador D a la derecha.

Filtro * ------------------------------------------------------------------- * Actualizamos las entradas * ------------------------------------------------------------------- LDAB xn+2 STAB xn+3 * x(n-3)= x(n-2) LDAB xn+1 STAB xn+2 * x(n-2)= x(n-1) LDAB xn+0 STAB xn+1 * x(n-1)= x(n) STAA xn+0 * x(n)= A (A= ADR2+ADR4) * ------------------------------------------------------------------- * Actualizamos las salidas excepto y(n) -> Objetivo de este algoritmo * ------------------------------------------------------------------- LDAB yn+2 STAB yn+3 * y(n-3)= y(n-2) LDAB yn+1 STAB yn+2 * y(n-2)= y(n-1) LDAB yn+0 STAB yn+1 * y(n-1)= y(n) * ------------------------------------------------------------------- * Se va acumulando las sumas y restas en la variable result * ------------------------------------------------------------------- LDX #0 * X = 0 STX result * result=0. Variable de 2 bytes donde se * va acumulando el resultado LDX #cx * X apunta al vector de coefic.de las entradas LDY #cy * Y apunta al vector de coefic. de las salidas * ------------------------------------------------------------------- LDAB 0,X * B= 20 Coeficiente de x(n) MUL * D= A.B = 20.x(n) ADDD result * D= D + result STD result * result= D * ------------------------------------------------------------------- LDAA yn+2 * A= y(n-2) LDAB 2,Y * B= 67 Coeficiente de y(n-2) MUL * D= A.B = 67.y(n-2) STD aux * aux= 67.y(n-2) LDD result SUBD aux * D= result - b2.y(n-2) STD result * result= D * ------------------------------------------------------------------- LDAA xn+1 * A= x(n-1) LDAB 1,X * B= 61 Coeficiente de x(n-1) MUL * D= A.B = 61.x(n-1) ADDD result * D= D + result STD result * result= D * ------------------------------------------------------------------- LDAA xn+2 * A= x(n-2) LDAB 2,X * B= 61 Coeficiente de x(n-2) MUL * D= A.B = 61.x(n-2) ADDD result * D= D + result STD result * result= D * ------------------------------------------------------------------- LDAA xn+3 * A= x(n-3) LDAB 3,X * B= 20 Coeficiente de x(n-3) MUL * D= A.B = 20.x(n-3) ADDD result * D= D + result STD result * result= D * ------------------------------------------------------------------- LDAA yn+1 * A= y(n-1) LDAB 1,Y * B= 16 Coeficiente de y(n-1) MUL * D= A.B = 16.y(n-1) ADDD result * D= D + result STD result * result= D * ------------------------------------------------------------------- LDAA yn+3 * A= y(n-3) LDAB 3,Y * B= 16 Coeficiente de y(n-3) MUL * D= A.B= 16.y(n-3) ADDD result * D= D + result STD result * result= D * ------------------------------------------------------------------- BITA #%10000000 * D es negativo (bit ms significativo es 1)? BNE Filtro2 * Si. Ir a Filtro2 LSLD * D=D

3. En este apartado se detallarn los puntos 3, 4 y 5 del enunciado.

Configuracin del convertidor analgico digital:

Registro Option: - Bit 7, ADPU: 1 lgico. Carga los condensadores que activan el convertidor. Registro ADCTL:

a. Bit 5, SCAN: 0 lgico. Indica que la conversin no es continua. b. Bit 4, MULT: 0 lgico. Indica que la conversin es simple. c. Bit 2,1,0, [CC,CB,CA]: 111 lgico. Indica que se convierte el pin PE7.

La seal de entrada hay que convertirla con la frecuencia de muestreo del filtro que es de 4 khz. Por tanto hace falta una rutina de interrupcin peridica con una periodicidad Tm= 1/fm.

Se utilizar el comparador OC5 para que el programa se pueda adaptar fcilmente en

el futuro a otra frecuencia de muestreo diferente. El periodo de repeticin de la rutina ser Tm= 1/4khz= 250s. El nmero de ciclos del contador TCNT necesarios para obtener el periodo Tm son 5003.

RTI

Orden de convertir

IntOC5_Tm

OC5F = 0TOC5= TOC5 + 500

Termin el CAD?

Si

No

A= ADR4

JSR Filtro

Resultado digital dela conversin del pinPE7

Ensamblador completo de la aplicacin teniendo presente que la seal analgica entra

por el pin PE7.

3 El periodo del contador TCNT es de 0,5 s. 500 x 0,5s = 250 s.

* ****************************************************************************** * * ********* Fichero: Filtro.ASM ******** * * ****************************************************************************** * * * ********************************************* * 1. CONSTANTES * ********************************************* REGBASE EQU $1000 TCNT EQU $0E _TCNT EQU TCNT+REGBASE TOC5 EQU $1E _TOC5 EQU TOC5+REGBASE TMSK1 EQU $22 OC5I EQU %00001000 * OC2I= TMSK1(3) TFLG1 EQU $23 OC2F EQU %00001000 * OC5F= TFLG1(3) OPTION EQU $39 * CAD: Config. _OPTION EQU OPTION+REGBASE ADPU EQU BIT7 * ADPU = OPTION(bit 7) ADCTL EQU $30 _ADCTL EQU ADCTL+REGBASE CA EQU %00000001 * CA = ADCTL(0) CB EQU %00000010 * CB = ADCTL(1) CC EQU %00000100 * CC = ADCTL(2) MULT EQU %00010000 * MULT= ADCTL(4) SCAN EQU %00100000 * SCAN= ADCTL(5) CCF EQU %10000000 * CCF = ADCTL(7) ADR4 EQU $34 _ADR4 EQU ADR4+REGBASE ************************* * * 2.- Variables Globales * ************************* * ORG $0000 * Zona de RAM interna xn RMB 4 yn RMB 4 result RMB 2 aux RMB 2 * ********************************************* * 3. BLOQUE INICIAL * ********************************************* ORG $E000 Inicio LDS #$00FF * SP= 00FFh LDX #REGBASE * X = 1000h BSET OPTION,X ADPU * ADPU=1. Activa el CAD (se cargan los condensadores) LDD TCNT,X ADDD #100 STD TOC5,X * TOC5= TCNT+100. *------------------------------------ * Iniciamos variables xn, yn *------------------------------------ CLR xn+0 * x(n) =0 CLR xn+1 * x(n-1)=0 CLR xn+2 * x(n-2)=0 CLR xn+3 * x(n-3)=0 CLR yn+0 * y(n) =0 CLR yn+1 * y(n-1)=0 CLR yn+2 * y(n-2)=0 CLR yn+3 * y(n-3)=0 *--------------------------------------------------------------- * Mscaras de interrupciones: I=0 (global) y OC2I=1 (local, TMSK1) *----------------------------------------------------------------- CLI * I=0 (CCR). Activa interrupciones BSET TMSK1,X OC5I * OC5I=1 (TMSK1).

* ********************************************* * 4. PROGRAMA PRINCIPAL * ********************************************* INF NOP BRA INF * Vuelve a iterar (bucle infinito) * ********************************************* * 4. Rutinas * ********************************************* Filtro -- * Ver en el apartado 2 de este ejercicio -- -- RTS * ******************************* * * 6.- Subrutinas de Interrupcin * * ******************************* * IntOC5_Tm LDX #REGBASE * X= 1000h (por si X != 1000h) LDD TOC5,X ADDD #500 STD TOC5,X * TOC5= TOC5 + 500 BCLR TFLG1,X %11110111 * OC5F= 0 LDAA #(CC+CB+CA) * ADCTL STAA ADCTL,X * SCAN=0, MULT=0, CC,CB,CA=111 (pin PE7) IntOC5_Tm1 BRCLR ADCTL,X %10000000 IntOC5_Tm1 * Esperar fin de la conversin LDAA ADR4,X * A= ADR2 (resultado de la conversin) *------------------ JSR Filtro * Recibe en A el nuevo dato x(n) *------------------ RTI *-------------------------------------------------------------------------------------- * IntError: Si ocurriera una interrupcin no vectorizada se ejecuta esta *-------------------------------------------------------------------------------------- IntError NOP RTI * ******************************** * * 7.- Vectores fijos o constantes * * ******************************** * cx FCB 20,61,61,20 cy FCB 128,16,67,16 * ***************************** * * 8.- Vector de interrupciones * * ***************************** *

ORG $FFC0 FDB IntError * $FFC0: Reservada FDB IntError * $FFC2: Reservada FDB IntError * $FFC4: Reservada FDB IntError * $FFC6: Reservada FDB IntError * $FFC8: Reservada FDB IntError * $FFCA: Reservada FDB IntError * $FFCC: Reservada FDB IntError * $FFCE: Reservada FDB IntError * $FFD0: Reservada FDB IntError * $FFD2: Reservada FDB IntError * $FFD4: Reservada FDB IntError * $FFD6: SCI. Sistema serie Ascrono FDB IntError * $FFD8: SPI. Sistema serie Sncrono. Transf. completa FDB IntError * $FFDA: Contador de Pulsos: Flanco de entrada FDB IntError * $FFDC: Contador de Pulsos: Desbordamiento FDB IntError * $FFDE: TO. Desbordamiento del contador TCNT. FDB IntError * $FFE0: OC5. Temporizador (Output Compare 5) FDB IntError * $FFE2: OC4. Temporizador (Output Compare 4) FDB IntError * $FFE4: OC3. Temporizador (Output Compare 3) FDB IntError * $FFE6: OC2. Temporizador (Output Compare 2) FDB IntError * $FFE8: OC1. Temporizador (Output Compare 1) FDB IntError * $FFEA: IC3. Temporizador (Input Capture 3) FDB IntError * $FFEC: IC2. Temporizador (Input Capture 2) FDB IntError * $FFEE: IC1. Temporizador (Input Capture 1) FDB IntError * $FFF0: RTI. Interrupcin de tiempo Real FDB IntError * $FFF2: IRQ. Interrupcin Externa o I/O Paralelo. FDB IntXIRQ * $FFF4: XIRQ. Interrupcin seudo no-enmascarable FDB IntError * $FFF6: SWI. Interrupcin software (Software Interrupt) FDB IntError * $FFF8: Cdigo ilegal. (Illegal Opcode Trap) FDB Inicio * $FFFA: COP Failure (Reset) () FDB IntError * $FFFC: COP Clock Monitor Fail (Reset) () FDB Inicio * $FFFE: /RESET

Curvas de algunas simulaciones

Los datos para una posible simulacin en la que se introduce una seal que es la suma de dos senoides cuyas frecuencias son inferiores a la de corte (1Khz):

Frecuencia (Hz) Valor medio (offset) Amplitud 50 2,94V 1.47V 150 0.69V 0.49V

La salida digital del convertidor es de un byte por lo que el rango de los datos de salida es 0-255 (eje de ordenadas de las siguientes curvas).

Aplicacin del

algoritmo (filtrado)

Los datos para otra simulacin en la que una de las senoides a sumar tiene una frecuencia superior4 a la frecuencia de corte de 1khz:

Frecuencia (Hz) Valor medio (offset) Amplitud 50 2,94V 1.47V

1500 0,49V 0,39V

Aplicacin del

algoritmo (filtrado)

4 La seal suma es la seal de 50hz ms un ruido que es la seal de 1500hz. El filtro atena de una forma extraordinaria este ruido y solo deja pasar su valor de continua (0,49V). El resultado del filtrado digital es la seal de 50 hz ms el valor de continua de la seal de 1,5Khz (desplazamiento hacia arriba).