PDF de programación - Generación de retardos en la familia 68HC908

Dto. Técnico EduDevices www.edudevices.com.ar
COMENTARIO TECNICO
Generación de retardos en la familia HC908

Por el Ing. Gabriel Dubatti – www.ingdubatti.com.ar

Introducción
Una tarea muy frecuente al programar microcontroladores es la generación de retardos, en general,
para controlar hardware periférico o para señalar distintos tipos de eventos mediante luces o sonidos.
En algunos casos puede utilizarse para generar estos tiempos el módulo de timer incorporado
en el microcontrolador, pero para muchos otros hay que buscar otras soluciones debido a los
inconvenientes que se verán a continuación.
Se muestra, a modo de ejemplo, como realizar una puerta serie por software en el procesador 68HC908JL3.

Generación de tiempos con el módulo de TIMER
El módulo de TIMER suele ser utilizado mediante interrupciones de la siguiente forma:

• Se elige un valor de prescaler (que determina el tiempo de avance del registro de 16 bits en

función de la frecuencia de bus). Cada cuenta en el TIMER es un "tick".

• Modo autorecargable: Se le da un valor de módulo al TIMER para que interrumpa por "Overflow"

indicando la cantidad de "ticks" deseados (esto genera un aviso periódico).

• Modo libre: Se indica en uno de los canales del TIMER dentro de cuantos "ticks" queremos que
Interrumpa sumando al valor actual del TIMER la cantidad de "ticks" deseados y recalculándolo
manualmente en cada interrupción.

El inconveniente de este método radica en lo que se denomina latencia de las interrupciones.
O sea la demora que se produce desde el evento de tiempo deseado y el momento en que realmente
se ejecuta el código.
Esta latencia tiene la desventaja de no ser predecible ya que en la ejecución de una interrupción
intervienen los siguientes factores: (si fuera predecible bastaría con restar al tiempo deseado al de la latencia)

• Esperar a que se destapen las interrupciones (bit I del registro CC):

Si estamos ejecutando una sección de código que tiene las interrupciones deshabilitadas, esta
esperará hasta que se habiliten para poder ejecutar. Este tiempo puede ser muy difícil de
estimar si estamos trabajando con varias interrupciones y no habilitamos la entrada de una
interrupción "sobre" otra.

• Esperar a que termine de ejecutar la instrucción en curso:

Las instrucciones se procesan en forma "atómica" (o sea en forma indivisible) y por lo tanto
para procesar una interrupción debe esperarse a que esta se complete. La cantidad de ciclos que
demora una instrucción en la familia HC908 está comprendida entre 1 y 9 ciclos de la frecuencia
de bus.

Ing. Daniel Di Lella: - Dedicated Field Application Engineer e-mail: [email protected]

Dto. Técnico EduDevices www.edudevices.com.ar

• Tiempo de salvado de registros

Cuando se logran las condiciones anteriores, el microcontrolador debe salvar el "contexto" actual
de trabajo. Para ello, inserta en el stack los registros: PC,X,A,CC con una demora adicional de
9 ciclos (suponiendo que demora lo mismo que la instrucción SWI). Este tiempo al ser fijo,
puede ser restado del tiempo deseado para corregirlo.

La latencia hace que el método de trabajo por interrupciones se utilice para generar tiempos relativamente
grandes en ciclos de bus, de modo que el error obtenido sea despreciable o promediado
(por ejemplo: si programamos el TIMER para generar 10 interrupciones por segundo con el modo
autorecargable, a pesar de la latencia, obtendremos 10 interrupciones por segundo cada una con una pequeña
demora distinta, pero "no acumulativa" ).

Para corregir estos efectos puede usarse el TIMER sin interrupciones. Esto es, leyéndolo y esperando a que
llegue al valor deseado. En este caso hay que tener cuidado con la comparación, ya que si se hace
"por igual" hay que estar seguro de que el tiempo que se demora entre lectura y lectura no haga que se pase
el valor deseado "de largo" sin verlo y si se compara por "mayor o igual" hay que tener cuidado con la
"circularidad" del registro (o sea, luego de $FFFF se vuelve a $0000 y lo que era mayor ahora es menor!).
Cuando los tiempos a generar son muy chicos (pocos ciclos) hay que tener en cuenta la incertidumbre del
prescaler del TIMER, ya que no sabemos en que valor se encuentra este divisor al iniciar el retardo.
Si deseamos generar retardos de distintas duraciones, deberemos buscar una unidad de interrupción que sea
común a todos los retardos y contar interrupciones para generar los eventos más largos.
Por ejemplo: si necesitamos retardos de 15 mseg, 50 mseg y 100 mseg, podemos usar 5 msegs de unidad y
contar 3, 10 y 20 interrupciones respectivamente o bien trabajar el timer en modo libre y programar
la demora en cada caso.

Generación de retardos por demora de las instrucciones
Dado que cada instrucción del procesador requiere una determinada cantidad de ciclos de bus para ser
completada, surge la posibilidad de utilizar este "efecto secundario" para generar retardos de duración
controlada. Y dado que las instrucciones demoran de 1 a 9 ciclos, pueden obtenerse retardos muy cortos
o largos y muy precisos.
Es de notar que para que el retardo sea de la duración deseada: el código debe ejecutarse con las
interrupciones deshabilitadas ya que si se presenta una interrupción, al tiempo transcurrido se le deberá
sumar todo el tiempo que tardo la interrupción en ejecutar. Si lo que se desea es un retardo de
"por lo menos" la demora dada, por ejemplo para generar un pulso de "strobe", no hay problema
en tener las interrupciones habilitadas.
Este método tiene el atractivo de poder realizar alguna función útil mientras se está esperando
(como borrar memoria, precargar registros, etc.).
La instrucción de demora por excelencia es "NOP" (no operación) que no hace nada salvo
demorar 1 ciclo la ejecución del programa. Para generar delay más largos podemos colocar varias
instrucciones NOP seguidas, pero consultando las hojas de datos del procesador surgen variantes
más interesantes:

Ing. Daniel Di Lella: - Dedicated Field Application Engineer e-mail: [email protected]

Dto. Técnico EduDevices www.edudevices.com.ar

Ciclos

Bytes

Código

1
2
2
2
2
2
3
3
4
5

5

5

6
7

7

8

9

9

16

1
1
1
1
1
2
1
2
2
1

3

3

2
1

3

3 (o 2)

3

4 (o 3)

2 (o 1)

NOP
SEI
CLI
DAA
TSX
NOP
NOP
NSA
BRN $
PSHA
PULA
MUL
PSHA
PULA
NOP
MOV $80,$80
NSA
NSA
DIV
PSHA
NSA
PULA
BSR rutina
..
rutina: RTS
NSA
NSA
NSA
JSR rutina
..
rutina: RTS
SWI
...
vector_swi: RTI

Comentarios

-
Fuerza I=1
Fuerza I=0
Invalida registro A
Invalida registros H y X
-
Intercambia nibbles del registro A
-
Utiliza y libera un byte del stack
Invalida registros A, X y CC (bits H y C)

Utiliza y libera un byte del stack

Invalida registro CC (bits V, N y Z)
Usar cualquier dirección en página 0.
-
Invalida registros A, X y H

Utiliza y libera un byte del stack

Utiliza y libera dos bytes del stack
Se puede utilizar un RTS existente y ahorrar un
byte.

Intercambia nibbles del registro A

Utiliza y libera dos bytes del stack
Se puede utilizar un RTS existente y ahorrar un
byte.
Utiliza y libera 5 bytes del stack
Se puede utilizar un RTS existente y ahorrar un
byte.

En la tabla se aclara que efecto colateral tiene realizar la demora con las instrucciones indicadas.
Por ejemplo: la instrucción "NSA" demora 3 ciclos pero intercambia los nibbles del registro A,
por lo que también se indica en la tabla que usando la instrucción "BRN xx" (branch never) se obtiene
una demora igual pero sin modificar ningún registro. También pueden ponerse 3 "NOP"s pero a expensas
de 1 byte extra y ningún beneficio.

Ing. Daniel Di Lella: - Dedicated Field Application Engineer e-mail: [email protected]

Dto. Técnico EduDevices www.edudevices.com.ar

Si las condiciones no nos permiten usar un ítem de la tabla, siempre podemos generar una demora
concatenando 2 o más ítems de la tabla que sí cumplan con las condiciones deseadas.
Cuando las demoras a generar son de muchos ciclos es mucho más compacto obtener dicha demora
por iteración. Así surgen los siguientes ejemplos:

Ciclos

Bytes

Código

Comentarios

769

5,8,11..770

773,776..1538

6,10,14..1026

8,14,20..1538

11,20,29..2306

3

4

6

5

5

6

CLRA
DBNZA $

LDA #CTE
DBNZA $

LDA #CTE
DBNZA $
DBNZA $

LDA #CTE
loop: NOP
DBNZA loop

LDX #CTE
loop: NSA
DBNZX loop

LDA #CTE
loop: NSA
NSA
DBNZA loop

Fuerza registro A= 0
Invalida registro CC (bits V=0, N=0 y Z=1)
Fuerza registro A= 0. Invalida registro CC (V, N y
Z)
delay= CTE * 3 + 2 (CTE=1..256)
256 => 0 (usar CLRA: un byte menos, 769 ciclos)
Fuerza registro A= 0. Invalida registro CC (V, N y
Z)
delay= CTE * 3 + 770 (CTE=1..256)
256 => 0 (usar CLRA: un byte menos, 1537 ciclos)
Fuerza registro A= 0. Invalida registro CC (V, N y
Z)
delay= CTE * 4 + 2 (CTE=1..256)
256 => 0 (usar CLRA: un byte menos, 1025 ciclos)
Fuerza registro X= 0. Invalida registro CC (V, N y
Z)
delay= CTE * 6 + 2 (CTE=1..256)
256 => 0 (usar CLRX: un byte menos, 1537 ciclos)
Si CTE es impar : intercambia nibbles del
registro A; si es par : mantiene A.
Fuerza registro A= 0. Invalida registro CC (V, N y
Z)
delay= CTE * 9 + 2 (CTE=1..256)
256 => 0 (usar CLRA: un byte menos, 2305 ciclos)

La ventaja de los métodos de demora por iteración es que cambiando las instrucciones que están
dentro del lazo, podemos cambiar la demora de cada iteración y por lo tanto el multiplicador
en la fórmula de "delay" (demora total).

Ing. Daniel D