Laboratorio de Procesamiento Digital de Señales Universidad Nacional de Córdoba NOTA DE APLICACIÓN. Introducción:

Transcripción

1 NOTA DE APLICACIÓN Ejemplo de implementación del microcontrolador MC68HC908GP32 en la multiplexación de displays usando módulo TIM por César Gianfelici, LabDSP FCEFyN UNC supervisado por Ing. Diego Dujovne, LabDSP FCEFyN UNC Introducción: Se realizó ésta aplicación con el fin de que sirva de ejemplo para los que quieran implementar el microcontrolador MC68HC908GPxx de Motorola en cualquier proyecto donde se necesite multiplexar displays de 7 segmentos. El ejemplo que se plantea es un cronógrafo donde se utilizan cuatro displays. Características: Cronógrafo_v1.0 es un programa hecho para el microcontrolador HC908GP32 de Motorola (y puede ser adaptado fácilmente a cualquiera de los otros de la gama) que maneja cuatro display 7 segmentos para realizar la muestra de segundos y minutos de un reloj. Se utilizan para el mismo 4 display de ánodo común. El punto del display 3 (siempre contando de izquierda a derecha en modo de visualización) denotará los segundos, se realizó de ésta forma con la idea de que, con pocas modificaciones, se pueden marcar minutos y horas quedando el punto de los segundos como referencia de éstos. El reloj marcará los segundos con los displays 1 y 2, además de los minutos que se realiza con los displays 3 y 4. Descripción: Para que se tenga una visualización mejor, antes de describir cada sección del programa se presentará el correspondiente diagrama de flujo. Las secciones que conforman el soft son: Página 1/17

2 Main Rutina de Interrupción del multiplexado de displays Rutina de Interrupción del timer del clock Descripción cuantitativa de cada sección: Main CONFIGURACIÓN DEL MICRO * Definición de bloques de memoria RAM ROM. * Definición de macro. * Definición de variables de la RAM. PROGRAMA PRINCIPAL * Configurar puerto A como salida. * Configurar puerto B como salida. * Configurar puerto D como salida. * Desabilitar el COP. * Cargar en las variables DISPLAY1 a DISPLAY4 $3F (0 en 7 segmentos) y $04 en la variable NDISP cantidad de displays). * Limpiar variables SEGUNDOS, MINUTOS, ENTRADA. * Configurar TIM1 para que interrumpa cada 1,5 milisegundos. * Configurar TIM2 para que interrumpa cada 0,5 segundos. LOOP Espera interrupción. Página 2/17

3 Al comienzo del programa se definen las posiciones de memoria del comienzo de la RAM, el del comienzo de la ROM y el del vector de inicio. La sentencia $Include 'gpregs.inc' incluye a este archivo en la compilación, el mismo, contiene la dirección de todos los registros del micro (por lo que no hace falta declarar la dirección de los registros utilizados en el programa). Luego se define una Macro, llamada t7s. Una macro es una plantilla para una secuencia de códigos. Después de que la macro es definida, donde se referencia al nombre de la macro se remplazará por la secuencia de códigos. Esta macro realiza la conversión de BCD a 7 segmentos. Luego se definen todas las variables de RAM que se usarán en el programa. La variable SEGUNDOS como la variable MINUTOS retienen las respectivas cuentas de segundos transcurridos y minutos. Las variables DISPLAYn tienen el valor que se mostrará directamente en dichos displays. La variable NDISP tiene el número del total de displays que se estarán multiplexando. En la variable ENTRADA solo se utiliza el bit menos significativo para que se encienda y apague el led indicador de segundos cada 0,5 segundos y habilita la cuenta del reloj cada vez que éste bit está en 1. Y la variable cont se utiliza como contador de uso general en la subrutina BINBCD (conversión formato binario a binario codificado en decimal). En el siguiente bloque se configuran los módulos a utilizar por medio de sus respectivos registros. Así, se configuran los puertos A, B y D como salida cargando en los registros DDRA, DDRB y DDRD respectivamente el dato $FF; se carga un 1 en el LSB del registro CONFIG1 llamado COPD, inhabilitando el COP del micro. La instrucción RSP inicializa el stack pointer, porque como en la mayoría de los M68HC05, la RAM sólo llega hasta $00FF. Sin embargo en la mayoría de los M68HC08 la RAM se extiende mas allá de $00FF. Por consiguiente, es necesario inicializar la pila en ésta dirección de memoria (se especifica desde que posición de RAM se utiliza como pila, entonces en cada PUSH la dirección de la pila se decrementará una posición). En el siguiente paso se cargan a cada una de las variables DISPLAY con $3F que es el número cero en codificación de 7 segmentos, así se mostrará, al iniciar la cuenta del reloj, a todos los displays en cero. Luego se carga a la variable NDISP con $04, el cual debe ser el número (en decimal) de displays que se estén por multiplexar. Después se limpian las variables SEGUNDOS, MINUTOS y ENTRADA para que comiencen con valor cero. Como la base de tiempo del reloj es el TIM2 y la base de tiempo para el multiplaxado de los displays es el TIM1, y al trabajar éstos con interrupciones, se los debe configurar antes de utilizarlos. Así, se carga al registro T1MODH con $0B y al registro T1MODL con $F6, ambos conforman parte alta y baja, respectivamente, del registro de 16 bits T1MOD, el cual se compara Página 3/17

4 constantemente con el contador de 16 bits; así que cuando se llegue a éste número, el timer generará un pedido de interrupción. El número $0BF6 (3062 en decimal) se calculó de forma que el pedido de interrupción se genere con una frecuencia de 400 hertz (2,5 mseg), teniendo en cuenta que el internal bus clock que ingresa al prescaler es la frecuencia del cristal utilizado para el micro dividida por un factor de cuatro. Entonces: F 4 clock 1 TMOD = ( F ) INTERRUPCION 1 TMOD = ( FINTERRUPCION) F 4 CLOCK 1 1 T 1MOD = 1 0,0025 _ seg Hz T1MOD = 3062 $0BF 6 Después se debe cargar el registro de control T1SC: Los bits PS0, PS1 y PS2 se cargan con ceros, ya que no se desea dividir el internal bus clock; luego se ponen a uno los bits TOIE y TRST, el primero de éstos Página 4/17

5 habilita la generación del pedido de interrupción por parte de TIM1 y el segundo limpia la cuenta para empezar a contar desde $0000. Al colocar un cero en el bit TSTOP se activa la cuenta. Así, se debe cargar a T1SC con $50. Para el TIM2, donde se quiere interrumpir cada 0,5 segundos, tenemos que el número a cargar en el registro T2MOD es: 0,5_ seg T 2MOD = Hz 416 T 2MOD = $9589 Nótese que el clock del cristal, lo dividimos otra vez por 16; ésta es la acción del prescaler que configuramos en T2SC: Entonces para que el prescaler divida al internal bus clock por 16 cargaremos 100 en los tres menos significativos PS2, PS1 y PS0 (ver página 357 del technical data), luego un 1 en TOIE y TRST. Por lo tanto se debe cargar al registro de control T2SC con $54. Con todo este procedimiento quedan configurados y andando los temporizadores, teniendo interrupciones cada 2,5 milisegundos con TIM1 y cada 0,5 segundos con TIM2. A partir de aquí, se entra en un ciclo loop llamado main_loop, donde se usa la instrucción wait que habilita las interrupciones y espera la petición de las mismas por los diferentes módulos. Página 5/17

6 Rutina de interrupción de multiplexado de displays dec NDISP NDISP=3? Yes DISPLAY1 --> PTB Selección de DISPLAY1 No NDISP=2? Yes DISPLAY2 --> PTB Selección de DISPLAY2 No NDISP=1? Yes DISPLAY3 --> PTB Selección de DISPLAY3 No DISPLAY4 --> PTB Selección de DISPLAY4 4 --> NDISP limpiar TOF Volver La variable NDISP se utiliza para seleccionar el display que se encenderá durante el multiplexado, en los cambios de valor que va experimentando realiza el barrido de los N displays. El puerto B se utiliza para los datos que se mostrarán en los displays y los bits 3, 4, 5, 6 del puerto A multiplexan a los mismos. Limpiar TOF es cargar éste bit del registro T1SC con un cero, marcando que ya se atendió la interrupción y dando lugar a que luego pueda solicitarse nuevamente la interrupción de este módulo. Página 6/17

7 Rutina interrupción del timer del clock inc ENTRADA apago el led del segundero Yes LSB de ENTRADA=0? No inc SEGUNDOS enciendo el led del segundero SEGUNDOS= 60? No Yes 0 --> SEGUNDOS inc MINUTOS MINUTOS= 60? No Yes 0 --> MINUTOS OUT2 Ir a BINBCD Ir a BCD7SEG OUT3 Limpiar TOF de T2SC Volver Página 7/17

8 La variable ENTRADA se utiliza para encender y apagar el led del segundero, así cuando el LSB de la variable ENTRADA vale cero, el programa salta a OUT3 para salir, si tuviera el valor uno sigue con la rutina. Por lo tanto la variable SEGUNDOS será incrementada en el doble del tiempo de la petición de interrupción del TIM2, es decir cada un segundo, que es lo pretendido. Cuando la verificación de que la variable SEGUNDOS o MINUTOS ha llegado al valor de 60 (decimal) es fácil, sólo se carga el número a comparar con la variable en el acumulador mediante lda #60T y luego se utiliza la instrucción cmp de la forma: cmp SEGUNDOS, ésta compara el valor de la variable SEGUNDOS con el valor que contiene el acumulador y según el resultado, modifica las banderas de estado. Si las variables no alcanzaron el valor de 60, el programa actualiza los datos de los displays por medio de dos subrutinas: BINBCD y BCD7SEG, luego sale de la rutina de interrupción. Si en cambio, se llegó a este valor la variable vuelve a cero y se incrementa en uno la variable posterior o, en caso de ser MINUTOS la que llegó a 60, solamente sale de la rutina por OUT2. OUT3 siempre se ejecuta inmediatamente después que OUT2, ya que es la que pone a cero al bit TOE del registro T2SC y así luego, pedir nuevamente la ejecución de toda esta rutina por medio de la correspondiente interrupción. 1) Subrutina BINBCD Ésta convierte un número binario a binario codificado en decimal. Página 8/17

9 SEGUNDOS --> A Ir a Resta cont --> DISPLAY2 DISPLAY1 --> A MINUTOS --> A Ir a Resta cont --> DISPLAY4 DISPLAY3 --> A Volver Página 9/17

10 Subrutina Resta 0 --> cont A <-- A - 10 N =1? No Yes inc cont A <-- A + 10 Volver Se carga el valor de la variable SEGUNDOS en el acumulador para que en la subrutina Resta, la instrucción sub realice la diferencia entre el acumulador (A) y el valor diez (10) decimal cargándose el resultado nuevamente en A y modificando las banderas de estado. Ahora: Si el resultado es negativo, el bit N (bandera) del registro CCR (condition code register) o registro de banderas, el programa suma diez al acumulador y sale de la subrutina Resta. Si el resultado no es negativo, se incrementa la variable cont y se vuelve a repetir el ciclo desde restarle diez a A. Luego se vuelve a la rutina principal y se vuelca el valor de cont en DISPLAY2, el valor que quede en el acumulador será colocado en el DISPLAY1. Se vuelve a repetir todo este proceso hasta aquí, para la variable MINUTOS, teniendo en cuenta que el valor de cont se volcará en DISPLAY4 y el del acumulador sobre DISPLAY3. Así, por ejemplo, si tenemos $0B en SEGUNDOS, al restarle $A (10 decimal) quedará el acumulador con un valor de 6 y cont con 1, cuando se vuelve a realizar la resta por $A el acumulador queda con un valor de $FC, pero como en ésta operación el bit N de CCR se puso en uno el programa sale de la subrutina Repite sumando $A al acumulador y sin Página 10/17

11 incrementar la variable cont. Así que el acumulador queda con un valor de $FC + $A = $06 y cont = $01; como la variable cont se carga en el DISPLAY2 y el acumulador en el DISPLAY1, en los dos displays que conforman la parte de los segundos del reloj, quedará conformado el número 16 (en decimal, ya que éstos resultados se convierten antes en código siete segmentos). El proceso de ejemplo que se describió, se repite para la variable MINUTOS. 2) Subrutina BCD7SEG Aplicar Macro t7s a DISPLAY1 Aplicar Macro t7s a DISPLAY2 Aplicar Macro t7s a DISPLAY3 Aplicar Macro t7s a DISPLAY4 Volver En éste caso se optó por la utilización de una macro para la conversión BCD a 7 segmentos, ya que código es repetitivo. Se aplica la Macro al valor que se mostrará en cada uno de los displays. $MACRO y $MACROEND son directivas de pre-procesador, la primera comienza la definición de una macro y la segunda indica que la macro ha sido definida. El %1 que acompaña a la instrucción lda toma el valor de la variable a Página 11/17

12 la que se aplica la macro, valor que es cargado en el acumulador. Luego, tax transfiere el contenido del acumulador a la parte baja del registro de indexado H:X, como éste registro es de 16 bits, se colocan ceros en la parte alta con la instrucción clrh. La siguiente instrucción: lda Tabla7seg,x toma de la tabla definida con db los valores según el valor de x, es decir que si x=0 tomará el primer valor que se encuentra en la tabla y si el valor es x=8 tomará el octavo valor de la tabla contando desde cero. En la definición de la tabla el símbolo % hace que el valor que le precede sea el valor que devuelva la tabla; por lo que éste es el valor que se carga en el acumulador. Por consiguiente en la tabla se definen todos los números que se necesitarán para la correcta visualización de los números en los displays. Observe que cada posición en la tabla corresponde a un número decimal el cual está representado por su número binario, colocado después del símbolo %, que es el código en 7 segmentos respectivo. Al final, la instrucción sta %1 transfiere el valor que está en el acumulador a la variable a la que se le aplicó la macro. Así se ha tomado el de cada variable DISPLAY y se lo a convertido a su equivalente en código de 7 segmentos para que pueda ser representado y visualizado en cada display. Con el rts último se vuelve a la rutina de interrupción, donde solo queda poner a cero el bit YOE del registro T2SC y salir de la rutina, para volver al bucle main_loop y aguardar por el próximo pedido de interrupción. Código del programa: RAMStart EQU $0040 RomStart EQU $E000 ; sector válido como ROM en GP20 y GP32 VectorStart EQU $FFDC $Include 'gpregs.inc' ; incluye todas las direcciones de los registros $MACRO t7s lda %1 tax clrh lda Tabla7segs,x sta %1 $MACROEND ; Macro que convierte de BCD a 7 segmentos Página 12/17

13 org RamStart MINUTOS ds 1 SEGUNDOS ds 1 DISPLAY1 ds 1 DISPLAY2 ds 1 DISPLAY3 ds 1 DISPLAY4 ds 1 NDISP ds 1 ENTRADA ds 1 cont ds 1 ; Se definen todas las variables a utilizar org RomStart *************************************************************** * Main_Init - Este es el punto donde comienza a ejecutarse el * * código después de un RESET. * *************************************************************** Main_Init: mov #$FF,DDRB ; Puerto B: Salida mov #$FF,DDRA ; Puerto A: Salida mov #$FF,DDRD ; Puerto D: Salida bset 0,CONFIG1 ; Desabilito COP rsp clra clrx ; SP <- $FF ; Inicializo A,X para que el ; proceso de interrupción no se ; detenga corriendo el riesgo de ; que no se inicialicen con el push A,X en stack mov #$3F,DISPLAY1 ; cargo 0 en DISPLAY1 (en 7 seg) mov #$3F,DISPLAY2 ; cargo 0 en DISPLAY2 mov #$3F,DISPLAY3 ; cargo 0 en DISPLAY3 mov #$3F,DISPLAY4 ; cargo 0 en DISPLAY4 mov #$04,NDISP clr SEGUNDOS clr MINUTOS clr ENTRADA ; variable que marca la entrada a rutina de TIM2 mov #$0B,T1MODH ; Timer mux display (400 hz) mov #$F6,T1MODL mov #$95,T2MODH ; Timer clock (0.5 hz) mov #$89,T2MODL mov #$54,T2SC ; inicia cuenta en TIM2 mov #$50,T1SC ; inicia cuenta en TIM1 main_loop: wait bra main_loop ; habilita y espera interrupciones Página 13/17

14 ****************************************** * Rutina de multiplexado de los displays * * Interrupción cada 2.5 mseg * ****************************************** TIMo1_isr: dec NDISP lda #$03 ; NDISP igual 3? cbeq NDISP,Y1 ; lda #$02 ; NDISP igual 2? cbeq NDISP,Y2 ; lda #$01 ; NDISP igual 1? cbeq NDISP,Y3 ; mov DISPLAY4,PTB mov #$BF,PTA ; selecciona Display4 mov #$04,NDISP bra OUT1 Y1: mov DISPLAY1,PTB mov #$F7,PTA ; selecciona Display1 bra OUT1 Y2: mov DISPLAY2,PTB mov #$EF,PTA ; selecciona Display2 bra OUT1 Y3: mov DISPLAY3,PTB mov #$DF,PTA ; selecciona Display3 OUT1: bclr 7,T1SC rti ***************************************** * Rutina de manejo del timer del reloj. * * Interrupción cada 0.5 segundo. * ***************************************** TIMo2_isr: inc ENTRADA ; este proceso es para encender el punto de los segundos bclr 0,PTD ; justo cuando se marca un nuevo segundo brclr 0,ENTRADA,OUT3 inc SEGUNDOS bset 0,PTD lda #60T cmp SEGUNDOS ; comparo para ver si SEGUNDOS llegó a 60 bne OUT2 clr SEGUNDOS inc MINUTOS lda #60T cmp MINUTOS ; comparo para ver si MINUTOS llegó a 60 bne OUT2 clr MINUTOS OUT2: jsr BINBCD ; subrutina de conversión binario --> BCD jsr BCD7SEG ; subrutina de conversión BCD --> 7 segmentos OUT3: bclr 7,T2SC rti Página 14/17

15 Tabla7segs: ; Tabla de conversión a 7 seg, utilizada por la Macro t7s db % ;0 db % ;1 db % ;2 db % ;3 db % ;4 db % ;5 db % ;6 db % ;7 db % ;8 db % ;9 BINBCD: lda SEGUNDOS jsr Resta ; salto a rutina Restador mov cont,display2 ; muestro en DISPLAY2 el resultado de la rutina Restador sta DISPLAY1 ; muestro en DISPLAY1 el ultimo digito del numero a convertir lda MINUTOS jsr Resta ; salto a rutina Restador mov cont,display4 ; muestro en DISPLAY4 el resultado de la rutina Restador sta DISPLAY3 ; muestro en DISPLAY3 el ultimo digito del numero a convertir rts Resta: clr cont Repite: sub #10T bmi Salida inc cont bra Repite Salida: add #10T rts BCD7SEG: t7s DISPLAY1 ; utilización de Macro para conversión BCD --> 7seg t7s DISPLAY2 t7s DISPLAY3 t7s DISPLAY4 rts ************************************************************** * DUMMY_ISR - Servicio de rutina a interrupción inservible. * * Solo hace que se retorne desde la interrupción. * ************************************************************** dummy_isr: rti ; retorna Página 15/17

16 ************************************************************** * Vectores - Servicio a interrupciones. * * Vectorización de las interrupciones * ************************************************************** org VectorStart dw TIMo2_isr dw TIMo1_isr dw main_init ; Time Base Vector ; ADC Conversion Complete ; Keyboard Vector ; SCI Transmit Vector ; SCI Receive Vector ; SCI Error Vector ; SPI Transmit Vector ; SPI Receive Vector ; TIM2 Overflow Vector ; TIM2 Channel 1 Vector ; TIM2 Channel 0 Vector ; TIM1 Overflow Vector ; TIM1 Channel 1 Vector ; TIM1 Channel 0 Vector ; PLL Vector ; ~IRQ1 Vector ; SWI Vector ; Reset Vector Harware utilizado: Página 16/17

17 Conclusión: Se trató de desarrollar un ejemplo en el que se utilice el Timer Interface Module (TIM) para mostrar su configuración y el cálculo de los valores a cargar en los registros TxMOD, que son los valores que se comparan con el del contador, para determinar así intervalos de tiempo. Se eligió este tipo de ejemplo, porque se consideró propicio para mostrar y/o repasar diferentes técnicas de programación básicas, utilizando el set de instrucciones de éstos microcontroladores, tales como Macros, configuración de temporizadores, interrupciones, multiplexación de displays, indexación de tabla, conversión binario a BCD, conversión BCD a 7 segmentos. El uso del Timer Interface Module es flexible ya que se pueden obtener las diferentes temporizaciones que se deseen utilizando también el prescaler, lo que aumenta las posibilidades de tener diferentes temporizaciones a emplear. El manejo de las interrupciones por vectorización de parte del micro hace mucho más práctico el diseño del soft a implementar, ya que brinda una mejor organización de las mismas. Bibliografía: TECHNICAL DATA - MC68HC908GP32 (HCMOS Microcontroller Unit) de MOTOROLA. TIM08 - Timer Interface Module (Reference Manual) de MOTOROLA. CENTRAL PROCESSOR UNIT (Reference Manual) de MOTOROLA. EVAL08GP - Manual del usuario de Electrocomponentes S.A. CASM08Z - 68HC08 Assembler Help de P&E Microcomputer Systems. Agradecimientos: Agradecemos la colaboración de Motorola por el apoyo ofrecido al Laboratorio y, en este caso, por el aporte de la bibliografía aquí utilizada. Además, agradecemos a la empresa Electrocomponentes S.A. que nos brindó la placa de emulación en circuito con los programas correspondientes para el uso de la misma, permitiéndonos así, programar, simular y emular nuestros proyectos. Dichos programas son, respectivamente, WINIDE v1.2, CASM08Z v3.16, ICS08GP v1.32, ICD08SZ v1.32 todos de P&E Microcomputer Systems, Inc. Copyright 2002 LabDSP FCEFyN UNC Córdoba, Argentina Página 17/17