Retardos, Temporización y Conteo de eventos

En muchas aplicaciones es necesario el conteo de eventos y la generación de acciones en instantes de tiempo

específicos. Por ejemplo:

 Al contar el número de pulsos generados por un encoder es posible conocer el desplazamiento angular de
un eje, y si además se analiza este desplazamiento durante un intervalo de tiempo es posible calcular la
velocidad angular.

 La implementación de algoritmos de procesamiento de señales sobre procesadores digitales (filtros

digitales, algoritmos de control digital, transformadas en tiempo discreto) requiere de la indicación del
periodo de muestreo que active la ejecución del algoritmo.

 Para calcular índices de producción en una empresa manufacturera se requiere contar el número de
productos terminados durante intervalos de tiempo establecidos para el proceso.

 La medición de cualquier frecuencia implica el conteo de eventos durante un intervalo de tiempo.

En computadoras es posible manejar bases de tiempo y contar eventos, tanto por medio de rutinas de software
como por el uso de dispositivos específicamente diseñados para este fin.

Generación de retardos por software

La idea básica de la generación de retardos por software consiste en implementar una rutina cuyo tiempo de
ejecución sea igual al retardo que se requiere. El método más simple implementado en todos los procesadores es
por medio de la instrucción NOP (No operar), la cual hace que no exista ningún cambio en el procesador durante
un ciclo de instrucción.

Dependiendo del procesador un ciclo de instrucción puede durar uno o más periodos de reloj del sistema. Debido
a la arquitectura interna del procesador AVR, en el Atmega2560 las instrucciones se miden en ciclos de reloj del
sistema. En particular la ejecución de una instrucción NOP tarda un periodo de reloj del sistema, por lo tanto si se
conecta un cristal de 16 MHz a un Atmega2560 el procesador se tardará 62.5 ns (1/16.000.000) en ejecutarla.

Con base en lo anterior, bastaría con ejecutar diez instrucciones NOP consecutivas para implementar un retardo
de 625 ns:
NOP
NOP
NOP
NOP
NOP
NOP
NOP
NOP
NOP
NOP

¿Cuántas instrucciones NOP consecutivas se tendrían que implementar para generar un retardo de 1 s utilizando
un Atmega2560 con un cristal de 16 MHz?, sería posible implementarlo de esta forma?.
Cuando los retardos requeridos son de larga duración se acostumbra utilizar ciclos, de tal forma que el código
generado no ocupe mucho espacio en la memoria de programa. Cuánto tiempo se tarda el procesador en ejecutar
el siguiente segmento de código?:

.DEF Contador = R16

LDI Contador,n ; Tarda un ciclo de instrucción en ejecutarse

Lazo: DEC Contador ; Tarda un ciclo de instrucción en ejecutarse

BRNE Lazo ; Tarda 1 ciclo si la condición es falsa y 2 ciclos si la condición es verdadera.

Para calcular el tiempo que tarda el procesador en ejecutar un segmento de código, es necesario analizar cuantas
veces se ejecuta cada instrucción del segmento y consultar en el manual del fabricante el tiempo que tarda el
procesador en ejecutar cada una de las instrucciones.

Para el código anterior, Retardo = (1x1T) + n[(1x1T) + (1x2T)] – 1T

1T + n(3T) – 1T
= 3nT

Cuál sería el retardo máximo que se podría alcanzar con la anterior rutina?. Qué hacer cuándo se requieren retardos
mayores?.

Como se puede observar, las rutinas de retardo consisten en segmentos de código que hacen que el
microprocesador gaste una cierta cantidad de ciclos de instrucción equivalentes al tiempo que se desea temporizar.
Debido a que durante este tiempo el procesador no realiza trabajo útil (procesar datos), este método solo se
recomienda para retrasos de corta duración.

Rutinas de conteo de eventos

Si lo que se desea es contar eventos externos se utilizan rutinas software que implementan el método de encuesta
para la detección de eventos. Este consiste en preguntar por el estado de uno de los terminales de los puertos del
microcontrolador y tan pronto se detecta la ocurrencia del evento se incrementa la variable que lleva el conteo total
de eventos.

.DEF Contador = R16; Registro contador

.DEF TEMP = R17

AQUÍ: IN TEMP,PINA ; Este segmento de código incrementa la variable

SBRC TEMP,0 ; Contador cada vez que detecta que el terminal
INC Contador ; PINA.0 está en 1 lógico.
JMP AQUÍ

Este método presenta dos inconveniente:

 Si los pulsos son de larga duración es necesario implementar una lógica de sincronización para evitar el
conteo de un mismo pulso por mas de una vez.
  Si el número de instrucciones realizadas entre encuestas simultáneas de los eventos es muy larga, se corre
el riesgo de que se filtren pulsos de corta duración.

Figura 1. Tren de pulsos

Temporización y conteo de eventos por hardware

En el microcontrolador se cuenta con componentes hardware especializados para el conteo de eventos internos o
externos, tales componentes se denominan temporizadores-contadores. Estos básicamente son contadores
programables a los cuales se le configura, entre otros, la señal de reloj que recibe el contador.

• Configuración como contador: conteo de eventos externos. En este caso los eventos que cuenta el
temporizador-contador ingresan a través de los terminales Tn de los puertos, y estos pueden ser o no
periódicos.

• Configuración como temporizador: conteo de eventos internos. La idea básica de la temporización por
hardware consiste en el conteo de eventos periódicos. Por ejemplo, suponga que existe un bombillo que
prende y apaga periódicamente cada segundo, si se deseara conocer cuando ha transcurrido un minuto
bastaría con contar 60 eventos en el bombillo.

Se considera que la frecuencia de oscilación de los cristales de las computadoras es bastante estable,
aunque puede verse afectada por cambios ambientales, como por ejemplo cambios de temperatura, razón
por la cual en algunas ocasiones las computadoras se almacenan en cuartos donde el ambiente está
controlado. Si se desprecian pequeños cambios en la frecuencia del oscilador esta señal se puede
considerar periódica y por lo tanto en el caso de la configuración como temporizador el temporizador-
contador contará periodos del reloj del sistema.

La ventaja de generar bases de tiempo por medio de temporizadores-contadores es que al ser estos un
hardware independiente al microprocesador, este último puede realizar sus actividades en forma paralela
al temporizador-contador respectivo. Esto quiere decir que mientras el temporizador-contador cuenta
periodos de reloj, el microprocesador puede estar realizando otro tipo de actividades. Además, por medio
de este método es posible disminuir las derivas temporales.
http://www.atmel.com/Images/Atmel-2549-8-bit-AVR-Microcontroller-ATmega640-1280-1281-2560-
2561_datasheet.pdf

Los temporizadores llevan el conteo en unos registros que pueden ser 8 o 16 bits dependiendo del
temporizador-contador seleccionado.

Cuando se configura el temporizador–contador como contador de eventos se acostumbra inicializar el

conteo desde 0.

Cuando se configura el temporizador-contador como temporizador es posible habilitar divisores de

frecuencia de la señal de reloj para lograr temporizaciones mayores. En este modo existen dos maneras
de realizar la configuración:
o En un caso se inicia el contador desde 0 y se configura un valor constante de tal forma que cuando
el conteo alcanza dicho valor se activa una bandera que indica que ya se contaron la cantidad de
periodos requeridos. Este método es muy útil para la generación de señales PWM.

o En el segundo caso se inicializa el contador con un valor de tal forma que al contar el número de
periodos requeridos se genere un desbordamiento del contador y se active una bandera de
desbordamiento.

Estas banderas pueden ser encuestadas o también pueden ser configuradas para que generen
interrupciones al procesador.

Tomado de: ATmega640/V-1280/V-1281/V-2560/V-2561/V [DATASHEET]

Ejemplo. Configuración del Temporizador-Contador 1 como temporizador de 1 segundo

generando interrupciones por desbordamiento

Para este caso es necesario configurar los siguientes registros:

o TCCR1B: En este registro se selecciona si el temporizador contador actuará como contador

de eventos externo o como temporizador (en el modo temporizador se debe seleccionar el
factor de divisor de frecuencia de la señal de reloj que se utilizará).
 ATmega640/V-1280/V-1281/V-2560/V-2561/V [DATASHEET]

o TCNT1: Es el registro donde se lleva el conteo y está compuesto por los registros TCNT1H y
TCNT1L (el temporizador-contador 1 es de 16 bits).

En este caso se desea temporizar a intervalos de 1 segundo, para lo cual se configurará un

prescaler (divisor de frecuencia) de 256. Si se considera un cristal de 16 MHz entonces 256
periodos de reloj equivaldrán a 16 µs (256/16.000.000 MHz). Por lo tanto se tendrán que contar
62.500 periodos de esta nueva señal para temporizar un segundo (1/16 µs).

Luego el valor de inicio de TCNT1H y TCNT1L se calcula de la siguiente manera:

65.536 = TCNT1 + número de periodos requeridos de la señal para completar la temporización

TCNT1 = 65.536 - número de periodos requeridos de la señal para completar la temporización

= 65.536 – 62.500 = 3.036 = 0x0BDC (TCNT1H=0x0B, TCNT1L=0xDC).

o TIMSK1. Es el registro en el que se habilita la interrupción por desbordamiento.

 ATmega640/V-1280/V-1281/V-2560/V-2561/V [DATASHEET]

En este ejemplo se implementan dos interrupciones, por cada flanco en el pin INT0 se niega el estado
de los bits del puerto A y cada un segundo se niega el estado de los bits del puerto B.

;====================================================================
; DEFINICIONES INICIALES
;====================================================================

.EQU F_CPU = 16000000

.DEF TEMP = R16 ; REGISTRO TEMPORAL
.DEF TEMP1 = R17 ; REGISTRO TEMPORAL 1
.DEF TEMP2 = R18 ; REGISTRO TEMPORAL 2

;====================================================================
; VECTORES DE INTERRUPCION
;====================================================================

.ORG 0x0000
JMP Inicio

.ORG 0x0002
JMP Int_Externa0

.ORG 0x0028
JMP InterrupcionT1 ; Desbordamiento del Timer 1

;====================================================================
; PROGRAMA
;====================================================================

Inicio:

;====================================================================
; CONFIGURACIÓN DE PERIFÉRICOS: PUERTOS A y B
;====================================================================

LDI TEMP,0xFF
OUT DDRB,TEMP ; Define el Puerto B como salida
OUT DDRA,TEMP ; Define el Puerto A como salida

LDI TEMP1,0xFF ; Inicializa el valor del puerto B

OUT PORTB,TEMP1 ; Escribe el dato almacenado en R17 en el Puerto B

LDI TEMP2,0xFF ; Inicializa el valor del puerto A

OUT PORTA,TEMP1 ; Escribe el dato almacenado en R18 en el Puerto A

;====================================================================
; CONFIGURACIÓN DE PERIFÉRICOS: TIMER 1
;====================================================================

; CONFIGURACIÓN DEL TIMER

LDI TEMP,0x0B ; SE PRECARGA EL TIMER 1
STS TCNT1H,TEMP ; CON 0x0BDC=3036
 LDI TEMP,0xDC ; VALOR NECESARIO PARA
STS TCNT1L,TEMP ; DESBORDAR A 1Seg

;CONFIGURACIÓN DEL PRESCALER:

LDI TEMP,1<<CS12|0<<CS11|0<<CS10 ; PRESCALER DE 256
STS TCCR1B,TEMP ; AQUÍ INICIA EL TIMER

;====================================================================
; HABILITAR INTERRUPCIONES INT0, TIMER 1 Y GLOBALES
;====================================================================
LDI TEMP,1<<TOIE1 ;Habilitación de INT_TIMER_1
STS TIMSK1,TEMP

LDI TEMP,1<<INT0 ; Habilitación de INT_EXT0

STS 0x003D,TEMP ; EIMSK

LDI TEMP,0x01 ; Selecciona activación por cualquier flanco

STS EICRA,TEMP

SEI ; Habilitador global de interrupciones

;====================================================================
; BUCLE INFINITO: LOOP
;====================================================================

BUCLE: NOP
JMP BUCLE ; BUCLE INFINITO

;====================================================================
; Subrutina de Atención a la Interrupción del Timer 1
;====================================================================

InterrupcionT1:

LDI TEMP,0x0B ;SE VUELVE A CARGAR

STS TCNT1H,TEMP ;EL TEMPORIZADOR 1
LDI TEMP,0xDC ;CON EL VALOR DE 3036
STS TCNT1L,TEMP ;DEBIDO AL DESBORDAMIENTO

COM TEMP1 ; Complemento a 1 el valor en el R16

OUT PORTB,TEMP1 ; Escribe el dato almacenado en R16 en el Puerto B

RETI

;====================================================================
; Subrutina de Atención a la Interrupción Externa 0
;====================================================================

Int_Externa0:

COM TEMP2 ; Complemento a 1 el valor en el R18

OUT PORTA,TEMP2 ; Escribe el dato almacenado en R18 en el Puerto A

RETI

;======================================================================
; FIN DEL PROGRAMA
;======================================================================