SISTEMAS ELECTRNICOS DIGITALES

Apellidos, Nombre:

Problema 2 (40%)

Septiembre 2006
.

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)=

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) ]
128

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(n1), 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:
|H(f)|

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

Pasabanda
Banda de transicin

Parabanda
2
fp

fs

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:
yn
xn
result
aux

ORG
RMB
RMB
RMB
RMB

$0000
4
4
2
2

* Acumula el resultado
* 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
cy

FCB
FCB

20,61,61,20
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)=

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) )
128

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.

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
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)=

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) )
128

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

PORTB= y(n)
5. Salir

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 << 1. Desplaza una posicin a la izqu.
BRA
Filtro3
Filtro2
Filtro3

CLRA
STAA
STAA
RTS

* A=0
yn+0
PORTB+REGBASE

(Saturacin para el caso de result < 0)

* y(n)= A (objetivo del algoritmo)

* PORTB= x(n)

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.

IntOC5_Tm
OC5F = 0
TOC5= TOC5 + 500

Orden de convertir

Termin el CAD?
Si

A= ADR4

No

Resultado digital de
la conversin del pin
PE7

JSR Filtro
RTI

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

por el pin PE7.

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
_TCNT

EQU
EQU

$0E
TCNT+REGBASE

TOC5
_TOC5

EQU
EQU

$1E
TOC5+REGBASE

TMSK1
OC5I

EQU
EQU

$22
%00001000

* OC2I= TMSK1(3)

TFLG1
OC2F

EQU
EQU

$23
%00001000

* OC5F= TFLG1(3)

OPTION EQU
_OPTION EQU
ADPU
EQU

$39
OPTION+REGBASE
BIT7

ADCTL
_ADCTL
CA
CB
CC
MULT
SCAN
CCF

EQU
EQU
EQU
EQU
EQU
EQU
EQU
EQU

$30
ADCTL+REGBASE
%00000001
%00000010
%00000100
%00010000
%00100000
%10000000

ADR4
_ADR4

EQU
EQU

$34
ADR4+REGBASE

************************* *
* 2.- Variables Globales *
************************* *
ORG
$0000
xn
RMB
4
yn
RMB
4
result RMB
2
aux
RMB
2

CAD: Config.

* ADPU = OPTION(bit 7)

*
*
*
*
*
*

CA =
CB =
CC =
MULT=
SCAN=
CCF =

ADCTL(0)
ADCTL(1)
ADCTL(2)
ADCTL(4)
ADCTL(5)
ADCTL(7)

* Zona de RAM interna

* *********************************************
* 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
CLR
CLR
CLR

yn+0
yn+1
yn+2
yn+3

*
*
*
*

y(n) =0
y(n-1)=0
y(n-2)=0
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
* Vuelve a iterar (bucle infinito)
BRA
INF
* *********************************************
* 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
*-----------------JSR
Filtro
*-----------------RTI

A= ADR2 (resultado de la conversin)

* Recibe en A el nuevo dato x(n)

*-------------------------------------------------------------------------------------* 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:
FDB
IntError
* $FFC2:
FDB
IntError
* $FFC4:
FDB
IntError
* $FFC6:
FDB
IntError
* $FFC8:
FDB
IntError
* $FFCA:
FDB
IntError
* $FFCC:
FDB
IntError
* $FFCE:
FDB
IntError
* $FFD0:
FDB
IntError
* $FFD2:
FDB
IntError
* $FFD4:
FDB
IntError
* $FFD6:
FDB
IntError
* $FFD8:
FDB
IntError
* $FFDA:
FDB
IntError
* $FFDC:
FDB
IntError
* $FFDE:
FDB
IntError
* $FFE0:
FDB
IntError
* $FFE2:
FDB
IntError
* $FFE4:
FDB
IntError
* $FFE6:
FDB
IntError
* $FFE8:
FDB
IntError
* $FFEA:
FDB
IntError
* $FFEC:
FDB
IntError
* $FFEE:
FDB
IntError
* $FFF0:
FDB
IntError
* $FFF2:
FDB
IntXIRQ
* $FFF4:
FDB
IntError
* $FFF6:
FDB
IntError
* $FFF8:
FDB
Inicio
* $FFFA:
FDB
IntError
* $FFFC:
FDB
Inicio
* $FFFE:

Reservada
Reservada
Reservada
Reservada
Reservada
Reservada
Reservada
Reservada
Reservada
Reservada
Reservada
SCI. Sistema serie Ascrono
SPI. Sistema serie Sncrono. Transf. completa
Contador de Pulsos: Flanco de entrada
Contador de Pulsos: Desbordamiento
TO. Desbordamiento del contador TCNT.
OC5. Temporizador (Output Compare 5)
OC4. Temporizador (Output Compare 4)
OC3. Temporizador (Output Compare 3)
OC2. Temporizador (Output Compare 2)
OC1. Temporizador (Output Compare 1)
IC3. Temporizador (Input Capture 3)
IC2. Temporizador (Input Capture 2)
IC1. Temporizador (Input Capture 1)
RTI. Interrupcin de tiempo Real
IRQ. Interrupcin Externa o I/O Paralelo.
XIRQ. Interrupcin seudo no-enmascarable
SWI. Interrupcin software (Software Interrupt)
Cdigo ilegal. (Illegal Opcode Trap)
COP Failure (Reset) ()
COP Clock Monitor Fail (Reset) ()
/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)
50
150

Valor medio (offset)

2,94V
0.69V

Amplitud
1.47V
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)
50
1500

Valor medio (offset)

2,94V
0,49V

Amplitud
1.47V
0,39V

Aplicacin
del
algoritmo
(filtrado)

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).