El uso de subrutinas lo vimos por primera vez en el tutorial Encendiendo y apagando LED’s… ahora con retardo! Ahí se vio la manera en la que se llama y se regresa de las subrutinas. También se dijo que el empleo de subrutinas hacía el código más entendible, otra forma de hacer el código entendible es mediante el uso de Macros.

Las macros son de alguna forma similares a las subrutinas ya que son conjuntos de intrucciones que se ejecutan de manera secuencial mediante una llamada a una orden de ejecución, sin embargo tiene diferencias muy significativas. Mientras que una subrutina aparece una sola vez en el código, cada vez que se “invoca” una macro se inserta el código de esta en el programa. Otra diferencia es que a una macro se le pueden especificar parámetros de entrada y a una subrutina no.

Una macro se define con la directiva macro especificando el nombre de la macro y los parámetros de entrada, si existieran, de la siguiente manera:
nombre_macro macro par1, par2,...
instrucción
instrucción
...
             endm

En el programa la definición de la macro debe aparecer antes de la línea en la que se llama la macro. Cuanto mientras se ejecuta el programa se encuentra una macro esta es reemplazada por el conjunto de instrucciones que aparecen en la definición de la macro. Una manera de asegurar eso es escribiendo las macros en un archivo include (.INC) y llamando a este include al momento de llamar el include de las definiciones del micro.

Las macros pueden ahorrar mucho tiempo de escritura ya que si hay partes del código que se repiten mucho se pueden escribir en una macro y ese código se insertaría de manera automática al llamar la macro. Veamos esto con un ejemplo. Los cambios de banco pueden ser muy repetitivos asi que si se quiere cambiar de banco se podrían definir unas macros de la siguiente manera:

banco0 macro             ; Definición de macro banco0
       bcf    STATUS,RP0 ; Bit RP0=0 = Banco 0
       endm              ; Termina definición de macro


banco1 macro             ; Definición de macro banco1
       bsf    STATUS,RP0 ; Bit RP0=1 = Banco 1
       endm              ; Termina definición de macro

Así si en el programa aparece el macro banco1 este será sustituido por el código bcf STATUS,RP0.

Con ese ejemplo tal vez no queda muy claro la ventaja de usar una macro ya que la macro solo contiene una instrucción y no utiliza parámetros, pero ahora que definimos esos macros definamos otro que designe un bit de un puerto como salida:

SALIDA macro    par1, par2 ; Definición de macro
       banco1              ; Macro para cambiar al banco 1
       bcf      par1, par2 ; Bit dado como salida
       banco0              ; Macro para cambiar al banco 0
       endm                ; Termina definición de macro

Para utilizar ese macro que contiene parámetros simplemente se llama de la siguiente manera:

       SALIDA   TRISA,3

Al llamara esa macro el primer parámetro dado TRISA toma el lugar de par1 mientras que el parámetro 3, el lugar de par2 generando el siguiente código:

    bsf STATUS,RP0 ; RP0 = 1 = Banco 1
    bcf TRISA,3    ; Bit 3 de Puerto A como entrada
    bcf STATUS,RP0 ; RP0 = 0 = Banco 0

Como se puede ver las macros hacen muy la escritura del código y al poder manejar parámetros proveen un medio para simplificar muchas operaciones.

Utilizando esos macros supongamos que realizamos un programa que ponga el alto el valor del bit 3 del puerto B. El código completo del programa sería:

    list    p=16f628a
    include p16f628a.inc
    include macros.inc ; Archivo con la definición de las macros

    org 0x00
    goto INICIO

    org 0x05
INICIO
    SALIDA  TRISB,3 ; Llamada a macro salida
    bsf     PORTB,3 ; Bit 3 del puerto B en alto

    goto    $       ; Ciclo infinito

    end

El programa principal es muy sencillo y legible. El archivo macros.inc donde se definen las macros quedaría así:

banco0 macro             ; Definición de macro banco0
       bcf    STATUS,RP0 ; Bit RP0=0 = Banco 0
       endm              ; Termina definición de macro


banco1 macro             ; Definición de macro banco1
       bsf    STATUS,RP0 ; Bit RP0=1 = Banco 1
       endm              ; Termina definición de macro

SALIDA macro  par1, par2 ; Definición de macro SALIDA
       banco1            ; Llamada a macro banco1
       bcf    par1, par2 ; Bit dado como salida
       banco0            ; Llamada a macro banco0
       endm              ; Termina definición de macro

Teniendo en cuenta las dos diferencias mencionadas podemos entonces preguntarnos ¿son mejores las macros o las subrutinas?. La respuesta final la debe dar cada quien ya que dependiendo del caso se debería usar una o la otra.

Más información sobre macros se puede encontrar en el quinto capítulo de PIC microcontrollers, for beginners too, de Nebojsa Matic.

Ya empezó un nuevo año así que vamos a empezar con un nuevo tutorial, esta vez con un cómo sobre multiplexación, cómo multiplexar una matriz de leds.

Si se quisiera controlar una sola columna de una matriz de 5×7 leds se necesitaría un puerto completo de un pic, 7 pines para controlar las filas y 1 para controlar la columna, eso significa que para controlar todos los leds de la matriz se necesitarían 4 puertos de 8 bits, demasiado para un microcontrolador, sobre todo para un 16F628a.

Para reducir el número de pines requeridos las cinco columnas de la matriz son multiplexadas, esto significa que solamente se necesitarán siete pines, uno por cada fila de la matriz, y cinco para habilitar cada una de las columnas.

Usando un pic 16F628a se puede utilizar el puerto B para controlar las filas y el puerto A para las columnas. La técnica de multiplexación consiste en mostrar una columna a la vez, mientras eso se haga lo suficientemente rápido parecerá que todas las columnas estan encendidas a la vez y no se verá ningún parpadeo, por esa misma razón la base de tiempo para la multiplexación es muy importante por lo que se utiliza la interrupción del timer 2 para esa tarea.

La multiplexación es muy sencilla y se ejecuta dentro de la rutina de interrupción del timer 2, se realiza más o menos de la siguiente manera:

• Espera interrupción
• Se deshabilitan las columnas
• Se escribe en el puerto B el valor de las filas
• Se habilita la primer columna
• Espera interrupción
• Se deshabilitan las columnas
• Se escribe en el puerto B el valor de las filas
• Se habilita la siguiente columna
• Espera interrupción
• …

Así se repite hasta llegar a la quinta columna, entonces la ejecución de la multiplexación vuelve al principio y se vuelve a repetir.

El programa de ejemplo muestra en conteo descendente los números del 9 al 0. La multiplexación se lleva a cabo en la rutina de interrupción del timer 2. El programa principal lo que hace es leer un número almacenado en una variable (un registro de memoria) y decodificarlo para ser desplegado en la matriz, como la matriz es de 5 columnas para decodificar el número se necesitan 5 registros donde se guardaran los valores de las filas de cada columna.

El diagrama del circuito de ejemplo es el siguiente:

Pueden ver un video de este ejemplo en YouTube

Descargar código: Multiplexar una matriz de 5×8 leds

Este tutorial está basado en el tutorial How to multiplex a matrix of LED’s.

El Timer 2 es un temporizador de 8 bits que tiene la particularidad de tener un preescalador y un post-escalador. Además este módulo cuenta con un registro de periodo PR2 que marca el valor máximo que puede alcanzar la cuenta del registro TMR2. A diferencia de los otros temporizadores, el temporizador Timer 2 no incrementa su cuenta hasta llegar a 0xFF y después al desborde sino que incrementa su cuenta desde 0×00 con cada ciclo de instrucción hasta que el valor del registro TMR2 coincide con el del registro PR2 y después, en el siguiente ciclo reinicia la cuenta desde 0×00.

Este módulo cuenta con un preescalador y un post-escalador. El preescalador tiene la misma función que en los otros dos timers y sirve
como divisor de frecuencia antes de cada incremento. El post-escalador funciona como un divisor de frecuencia después de cada coincidencia
entre los registros TMR2 y PR2. Si el post-escalador es 1:1 la bandera de interrupción TMR2IF se habilitará en cada coincidencia entre TMR2 y PR2, en cambio si por ejemplo el post-escalador es 1:16, la interrupción se presentará cada 16 coincidencias.

Este temporizador, al igual que el Timer 1, puede habilitarse y deshabilitarse mediante el bit TMR2ON.

El preescalador se selecciona con los bits T2CKPS1:T2CKPS0 y el post-escalador con los bits T0UTPS3:TOUTPS0 de la siguiente manera:

Preescalador        Post-escalador
 00 = 1:1            0000 = 1:1
 01 = 1:4            0001 = 1:2
 1x = 1:16           0010 = 1:3
			  .
			  .
			  .
		     1111 = 1:16

Carga y Temporización

La temporización del Timer 2 está dada por la siguiente expresión:

TempTMR2 = [Preescaler*(PR2+1)*Postscaler]*Tinstr

Donde
Preescaler = Valor del preescalador
PR2 = Valor cargado al registro PR2
Postscaler = Valor del post-escalador
Tinstr = 4/frecuencia de oscilación
TempTMR2 = Temporización dada en segundos

La temporización máxima que puede alcanzar el Timer 2 es la misma que alcanza el Timer 0. Utilizando el oscilador interno del pic 16f628 la temporización máxima sería de 65536uS. Si se desea otra temporización se puede lograr cargando el valor necesario al registro PR2.

PR2 = [([TempTMR2/(4/fosc)])/(Preescaler*Postscaler)]-1

Veamos el mismo ejemplo de los temporizadores anteriores, ahora aplicado al Timer 2: Se desea complementar el valor del puerto B cada
50ms. Se estará revisando que se haya cumplido el tiempo de la temporizacion checando la bandera TMR2IF. Utilizando la expresión de la
precarga y utilizando el preescalador y el post-escalador más grande (16) obtenemos el valor quer que necesitamos cargar al registro PR2 para obtener una temporizacion de 50mS.

PR2 = [([50mS/(4/4Mhz)])/(16*16)]-1 = 194.31

Ya que no podemos cargar numeros fraccionarios el valor del registro PR2 necesario es 194. El código del programa sería el siguiente:

INICIO
	bsf     STATUS,RP0
	clrf    TRISB
	bcf     STATUS,RP0
	movlw   b'01111010'
	movwf   T2CON
	clrf    PORTB
	bcf     PIR1,TMR2IF

PRECARGA
	bcf     T2CON,TMR2ON
	bsf     STATUS,RP0
	movlw   .194
	movwf   PR2
	bcf     STATUS,RP0
	bsf     T2CON,TMR2ON

ESPERA
	btfss   PIR1,TMR2IF
	goto    ESPERA
	bcf     PIR1,TMR2IF
	comf    PORTB,f
	goto    PRECARGA

Descargar código: Ejemplo del temporizador Timer 2

El Timer 1 es un módulo temporizador/contador de 16 bits, que consiste en dos registros de 8 bits (TMR1H y TMR1L) que son de lectura y escritura. Este módulo incrementa su cuenta desde 0×000 hasta 0xFFFF y al desbordarse vuelve a 0×0000. Al presentarse el desborde la bandera de interrupción TMR1IF se pone a 1 y, si está habilitada, la interrupción se presenta.

Este módulo al igual que el Timer 0 puede funcionar en modo temporizador y en modo contador. En modo temporizador el par de registros TMR1 se incrementa en cada ciclo de instrucción, este modo se selecciona poniendo a 0 el bit TMR1CS del registro T1CON. En modo contador el par de registros TMR1 se incrementa en cada flanco ascendente de una señal de reloj externa, este modo se selecciona poniendo a 1 el bit TMR1CS del registro T1CON.

El preescalador del Timer 1 tiene un valor máximo de 8 y se selecciona con los bits T1CKPS1:T1CKPS0 de la siguiente manera:

 00 = 1:1
 01 = 1:2
 10 = 1:4
 11 = 1:8

A diferencia del Timer 0, el Timer 1 tiene la posibilidad de activar o detener la cuenta mediante el bit TMR1ON del registro T1CON.

Carga y Temporización

En modo temporizador el Timer 1 incrementa su cuenta en cada ciclo de instrucción. La temporización que se puede obtener con este módulo se obtiene de la siguiente relación:

TempTMR1 = [(65536 - precarga)*PS]*Tinstr

Donde:
precarga = Valor que se le asigna al par de registros TMR1 al comenzar la temporización
PS = Valor del preescalador
Tinstr = 4/frecuencia de oscilación
TempTMR1 = Temporización dada en segundos

La temporización máxima utilizando el oscilador interno del pic 16f628 y el valor más grande de preescalador es:

TempTMR1.Max = [(65536 - 0)*8]*1uS = 524288uS

De modo que la temporización máxima que se puede tener con este temporizador, utilizando el oscilador interno de 4Mhz del pic 16f628,
es de 524.288mS. Con la misma frecuencia de oscilación el Timer 0 solamente podia lograr una temporización de 65.538mS así que con el
Timer 1 se logran temporizaciones de mayor duración. Si se desea obtener una temporización distinta solo se debe escribir en el par de registros TMR1 el valor de la precarga necesaria para la temporización deseada.

precarga = -[([Temporizacion/(4/fosc)])/PS]+65536

Veamos el mismo ejemplo que el del temporizador Timer 0 ahora aplicado al Timer 1: Se desea complementar el valor del puerto B cada 50mS. Se estará revisando que se haya cumplido el tiempo de la temporización checando la bandera TMR1IF. Utilizando la expresión de la precarga y utilizando el preescalador más grande (8) obtenemos el valor que necesitamos cargar al par de registros TMR1 para obtener una temporización de 50mS.

precarga = -[([50mS/(4/fosc)])/8]+65536 = 59286 = 0xE796

Así que para obtener una temporización de 50mS mediante el Timer 1 se debe cargar 0xE7 al registro TMR1h y 0×96 al registro TMR1L. El código del programa sería el siguiente:

INICIO
    bsf     STATUS,RP0
    clrf    TRISB
    bcf     STATUS,RP0
    movlw   b'00110000'
    movwf   T1CON
    clrf    PORTB
    bcf     PIR1,TMR1IF

PRECARGA
    bcf     T1CON,TMR1ON
    movlw   0xE7
    movwf   TMR1H
    movlw   0x96
    movwf   TMR1L
    bsf     T1CON,TMR1ON

ESPERA
    btfss   PIR1,TMR1IF
    goto    ESPERA
    bcf     PIR1,TMR1IF
    comf    PORTB,f
    goto    PRECARGA

La configuración del Timer 1 se realiza mediante las líneas “movlw b’01100000′” y “movwf T1CON“. Mediante estas lineas se configura el timer en modo temporizador (TMR1CS = 0) y se selecciona el preescalador máximo (T1CKPS1:T1CKPS0 = 11). Una vez configurado el timer 1 se limpia el puerto B y la bandera TMR1IF del registro PIR1. Posteriormente se realiza la precarga cargando un 0xE7 al registro TMR1H y un 0×96 al registro TMR1L. Nótese que antes de realizar la carga se detuvo el timer poniendo a 0 el bit TMR1ON, esto se hace para evitar errores al momento de cargar el valor a los registros TMR1, después de realizar la carga se enciende el timer poniendo a 1 el bit TMR1ON y en ese momento la temporización comienza.

Para saber si la temporización terminó se está revisando continuamente la bandera TMR1IF. Mientras esta sea 0 la temporización aún no habrá terminado, cuando la bandera es 1 entonces la temporización finalizó, entonces se borra la bandera TMR1IF, se complementa el puerto B y se vuelve a realizar la precarga. De este modo el programa está complementado el puerto B cada 50mS.

Descargar código: Ejemplo del temporizador Timer 1

El Timer 0 es un modulo temporizador/contador de 8 bits que cuenta con un preescalador programable también de 8 bits. Puede funcionar como temporizador o como contador. En modo temporizador el valor del registro TMR0 se incrementa con cada ciclo de instrucción (o cada X ciclos dependiendo del preescalador). En modo contador el valor del registro TMR0 se incrementa en cada flanco (ascendente o descendente) del pin RA4/T0CKI. En ambos casos al desbordarse (pasar de 0xFF a 0×0) el registro TMR0 la bandera de interrupción del timer 0 (bit T0IF del registro INTCON) se pone a 1.

El modo temporizador se selecciona poniendo a cero el bit T0CS del registro OPTION. Poniendo a uno ese bit el modulo trabaja en modo
contador, en este modo de operación además se debe seleccionar si el incremento se producirá en cada filo ascendente o descendente, al poner a cero el bit T0SE del registro OPTION se selecciona el filo ascendente.

El preescalador es compartido por el Timer 0 y por el Watchdog. Se asigna a un módulo o a otro mediante el bit PSA del registro OPTION. Poniendo el bit a 1 el preescalador se asigna al Watchdog y poniendolo a 0 el preescalador se asigna al Timer 0. El valor del preescalador se selecciona con los bits PS2:PS0 de la siguiente manera:

PS2:P20    TMR0    WDT
  000      1:2     1:1
  001      1:4     1:2
  010      1:8     1:4
  011      1:16    1:8
  100      1:32    1:16
  101      1:64    1:32
  110      1:128   1:64
  111      1:256   1:128

Carga y temporización

En modo temporizador el Timer 0 incrementa su cuenta en cada ciclo de instrucción. Este modo sirve para generar temporizaciones y bases de tiempo de la misma forma que los retardos por software, sin embargo las temporizaciones con el Timer 0 pueden ser más exactas y además se cuenta con la ventaja de que el módulo puede trabajar mediante interrupciones así que el programa puede ejecutar otras isntrucciones mientras se realiza la temporización.

La temporización que se puede obtener con este módulo se obtiene de la siguiente relación:

Temporización = [(256 - precarga)*PS+2]*Tinstruccion

Donde:
precarga = Valor que se le asigna al registro TMR0 al comenzar la temporización
PS = Preescalador. Si esta asignado al watchdog tomará el valor de 1
Tinstrucción = 4/frecuencia de oscilación
y la temporización está dada en segundos.

La temporización máxima utilizando el oscilador interno del pic 16f628 es:

Temp.max. = [(256 - 0)*256+2]*1uS = 65528uS

De modo que la temporizacion máxima que se puede tener con el es solamente de 65.538mS. Si se desea obtener una temporizacion distinta solo se debe escribir en el registro TMR0 el valor de la precarga necesaria.

precarga = -[([Temporizacion/(4/fosc)]-2)/PS]+256

Donde, de nuevo, la temporización está dada en segundos.

Veamos un ejemplo de aplicación: Se desea complementar el valor del puerto B cada 50mS. Se estará revisando que se haya cumplido el tiempo de la temporización checando la bandera T0IF. Utilizando la expresión de la precarga y utilizando el preescalador más grande (256) obtenemos el valor que necesitamos cargar al registro TMR0 para obtener una temporización de 50mS.

precarga = -[([50mS/(4/4Mhz)]-2)/256]+256 = 60.69 ≈ 60

Ya que no podemos cargar numeros fraccionarios el valor de precarga necesario es 60. Teniendo entonces el valor de la precarga el código del programa sería el siguiente:

INICIO
    bsf     STATUS,RP0
    clrf    TRISB
    movlw   b'00000111'
    movwf   OPTION_REG
    bcf     STATUS,RP0
    clrf    PORTB
    bcf	    INTCON,T0IF

PRECARGA
    movlw   .60
    movwf   TMR0

ESPERA
    btfss   INTCON,T0IF
    goto    ESPERA
    bcf     INTCON,T0IF
    comf    PORTB,f
    goto    PRECARGA

La configuración del Timer 0 se realiza mediante las líneas “movlw b’00000111′” y “movwf OPTION_REG“. Mediante estas lineas se configura el timer en modo temporizador (T0CS = 0), el preescalador se asigna al timer 0 (PSA = 0) y se selecciona el preescalador máximo (PS2:PS0 = 111). Una vez configurado el timer 0 se limpia el puerto B y la bandera T0IF. Posteriormente se realiza la precarga cargando un 60 al registro TMR0 y en ese momento la temporización comienza.

Para saber si la temporización terminó se está revisando la bandera T0IF. Mientras esta sea 0 la temporización aún no habrá terminado, cuando la bandera es 1 entonces la temporización finalizó, se borra la bandera, se complementa el puerto B y se vuelve a realizar la precarga. De este modo el programa está complementado el puerto B cada 50mS.

Descargar código: Ejemplo del temporizador Timer 0

Numero Binario de 8 bits a BCD mediante el algoritmo Recorre y Suma+3

En la entrada anterior se encuentra una rutina para convertir un numero Binario de 8 bits a BCD empleando un metodo de division po restas sucesivas. En esta ocasion presento una rutina para lograr la misma conversion de Binario a BCD empleando el algoritmo Recorre y Suma+3.

El algoritmo funciona de la siguiente manera:

• Recorre 1 bit a la izquierda el numero binario.
• Si se han hecho 8 corrimientos, el numero BCD se encuentra en las columnas CENTENAS, DECENAS y UNIDADES.
• Si el valor binario de cualquiera de las columnas BCD es 5 o mayor, se suma 3 al valor en esta columna BCD.
• Si se desea convertir un byte despues de haber efectuado 8 corrimientos la conversion ha finalizado, para 2 bytes se necesitarian 16 y asi sucesivamente.

Es un metodo muy facil de entender y aplicar. Utilizando este algoritmo la rutina que permite convertir un numero binario de 8 bits a BCD es la siguiente:

BIN2BCD_RS3
        clrf     BCDH
        clrf     BCDL

        movlw    0x08
        movwf    CUENTA

CONVERSION1
        bcf      STATUS,C
        rlf      BIN,f
        rlf      BCDL,f
        decfsz   CUENTA,f
        goto     $+2
        goto     TERMINA_CONVERSION
        movlw    b'00001111'
        andwf    BCDL,w
        movwf    BCD_TEMP
        movlw    0x05
        subwf    BCD_TEMP,w
        btfsc    STATUS,C
        call     SUMA0x03
        movlw    b'11110000'
        andwf    BCDL,w
        movwf    BCD_TEMP
        movlw    0x50
        subwf    BCD_TEMP,w
        btfsc    STATUS,C
        call     SUMA0x30
        goto     CONVERSION1

TERMINA_CONVERSION
        return 

Al igual que la rutina anterior, antes de llamar a esta rutina de conversion es necesario tener almacenado el numero que se desea convertir en la variable BIN. Al finalizar la rutina el numero BCD estara almacenado en las variables BCDH y BCDL. El nibble bajo de BCDH tendra almacenadas las CENTENAS, el nibble alto de BCDL las DECENAS y el nibble bajo de BCDL las UNIDADES.

De nuevo hay que tener en cuenta que al realizar la conversion el numero que se tenia en un principio en la variable BIN es destruido, asi que se debe tener un respaldo de su valor en otro registro si se desea seguir trabajando con el.

Las rutinas SUMA0×03 Y SUMA0×30 simplemente se encargan de sumar 3 a la columna BCD que lo necesite. Estas rutinas se encuentran en el codigo de la rutina.

Descargar codigo: Conversion numero Binario de 8 bits a BCD – Recorre y Suma+3

Convertir un numero Binario de 8 bits a BCD

El Codigo binario decimal (BCD) es un codigo para numeros decimales en el que cada digito es representado por su propia secuencia binaria. Su principal ventaja es que permite una conversion facil a digitos decimales para su despliegue y permite tambien realizar calculos decimales mas rapidos.

Aqui se presenta una rutina para convertir un numero binario a BCD, precisamente un numero de 8 bits (1 byte) a su equivalente BCD. El valor maximo de un byte es 0xFF = 255, asi que al convertir un numero binario de 8 bits se obtienen 3 digitos BCD.

Esta rutina convierte el numero binario a su equivalente BCD empaquetado. El resultado de la conversion del numero binario a BCD ocupa un byte y medio y se representa en las variables de memoria BCDH y BCDL. El numero binario a convertir debe estar almacenado en la variable BIN.

ej. 0xFF = 255
 BIN -> BCDH:BCDL
  FF     02   55

La conversion se hace realizando divisiones mediante restas sucesivas. Primero entre 100 para obtener el nibble bajo de BCDH y despues entre 10 para obtener el nibble alto de BCDL y el residuo pasa a formar el nibble bajo de BCDL.

El codigo de la rutina es el siguiente:

BIN8_BCD3
        clrf    BCDH
        clrf    BCDL
BCD_HIGH
        movlw   .100
        subwf   BIN,f
        btfss   STATUS,C
        goto    SUMA_100
        incf    BCDH,f
        goto    BCD_HIGH
SUMA_100
        movlw   .100
        addwf   BIN,f
        movlw   0x0F
        movwf   BCDL
BCD_LOW movlw   .10
        subwf   BIN,f
        btfss   STATUS,C
        goto    SUMA_10
        incf    BCDL
        movlw   0x0F
        iorwf   BCDL
        goto    BCD_LOW
SUMA_10 movlw   .10
        addwf   BIN,f
        movlw   0xF0
        andwf   BCDL,f
        movf    BIN,w
        iorwf   BCDL,f

        return

Antes de llamar a la rutina de conversion es necesario tener almacenado el numero que se desea convertir en la variable BIN. Al finalizar la rutina el numero BCD estara almacenado en las variables BCDH y BCDL. BCDH tendra el numero BCD mas significativo mientras que en BCDL se encontraran los dos numeros restantes, siendo el nibble alto de BCDL el mas significativo de los dos y el nibble bajo de BCDL el menos significativo.

De este modo se logra convertir un numero binario de 8 bits a su equivalente BCD. Solamente hay que tener en cuenta que al realizar la conversion el numero que se tenia en un principio en la variable BIN es destruido, asi que se debe tener un respaldo de su valor en otro registro si se desea seguir trabajando con el.

Descargar codigo: Conversion numero Binario de 8 bits a BCD

Una interrupción es un evento que hace que el microcontrolador deje de ejecutar la tarea que está realizando para atender dicho acontecimiento y luego regrese y continue la tarea que estaba realizando antes de que se presentara la interrupción. El pic 16F628 (y el 16F628A) tiene 10 fuentes de interrupción, si las interrupciones están habilitadas cada vez que una de estos acontecimientos se presente el pic dejará de ejecutar el programa para ir a atender la interrupción y al termino de la misma continuará ejecutando el programa donde lo había dejado. Las fuentes de interrupción son:

• Interrupción externa RB0/INT
• Interrupción por cambio lógico en el puerto B (pines RB7 a RB4)
• Interrupción por desborde del timer 0 (TMR0)
• Interrupción por desborde del timer 1 (TMR1)
• Interrupción por comparación exitosa exitosa en TMR2
• Interrupción del comparador
• Interrupción del transmisor del USART
• Interrupción del receptor del USART
• Interrupción del módulo CCP
• Interrupción del EEPROM

Aunque el pic cuenta con 10 fuentes distintas de interrupción solamentetiene un vector de interrupción por lo que si se habilitan varias interrupciones al momento de presentarse cualquiera de ellas el programa saltara a la misma rutina de interrupcion y es responsabilidad del programador crear una rutina que identifique la fuente de la interrupcion.

Los registros asociados con las interrupciones son el registro de control de interrupcion INTCON, el registro habilitacion de interrupciones de perifericos PIE1 y el registro de interrupciones de perifericos PIR1. En el registro INTCON se encuentra el bit de habilitacion global de interrupciones GIE, el bit de habilitacion de interrupcion por perifericos PEIE y los bits de habilitacion de algunas interrupciones como la interrupcion externa del pin RB0 (INTE), la interrupcion por cambio de estado en los pines RB4 a RB7 (RBIE) y la interrupcion por desborde del timer 0 (T0IE), asi como las banderas correspondientes a cada interrupcion (INTF, RBIF y T0IF). En el registro PIE1 se encuentran los bits de habilitacion de las demas interrupciones y en el registro PIR1 se encuentran las banderas asociadas con cada interrupcion.

Para habilitar las interrupciones se deben seguir los siguientes pasos:

• Habilitar el bit correspondiente a cada interrupcion.
• Limpiar la bandera correspondiente a la interrupcion habilitada para evitar falsas interrupciones.
• En caso de ser necesario habilitar el bit PEIE del registro INTCON (necesario para todas las interrupciones con excepcion de INTE y RBIE).
• Habilitar el bit de habilitacion global de interrupciones GIE del registro INTCON.

En el codigo tambien es necesario indicar hacia que rutina debe saltar el programa al presentarse la interrupción. Ya se dijo que el vector de interrupción está en la dirección 0×04 por lo que es necesario agregar las lineas org 0×04 y goto ISR al programa, donde ISR es la rutina de servicio de interrupción y puede, desde luego, tener cualquier otro nombre.

La ventaja de utilizar interrupciones es que mientras se espera a que se presente el evento que produce la interrupción el microcontrolador puede estar ejecutando cualquier otra tarea. De ese modo el micro no esta ciclado en una sola tarea sino que puede seguir trabajando en otras hasta que una interrupción haga que el programa salte y ejecute la tarea que se quiera y al terminarla el programa continuara su ejecución en el punto en el que se encontraba en el momento de presentarse la interrupción.

En el ejemplo pasado se vió como leer botones e interruptores, ahora se va a realizar el mismo programa pero haciendo uso de interrupciones y para que se aprecie que el microcontrolador puede realizar otra tarea mientras se espera la interrupción el programa hará que parpadee el puerto A cada medio segundo. Por lo demas el programa sera igual, tendra 4 botones conectados a los pines RB4 a RB7 y 4 leds conectados a la parte baja del puerto B. Se habilitarán las interrupciones y de ese modo los botones se leerán solamente al ser presionados. Veamos entonces el codigo:

Ese es el código del programa principal. Se comienza declarando el vector de reset y el vector de interrupcion, después se configuran los puertos, el puerto A como salida, la parte baja del puerto B como salida y la parte alta del puerto B como entrada. Hasta ahí lo único nuevo es la declaración del vector de reset. Después se configuran las interrupciones: Primero se habilita el bit RBIE del registro INTCON que es el correspondiente a la interrupción por cambio de estado en los pines RB4 a RB7, después se pone a cero el bit RBIF del mismo registro para poner la bandera de interrupción en cero y así evitar entrar a la rutina de servicio sin que exista una interrupción, y por último se habilita el bit GIE para habilitar las interrupciones. De esta manera la interrupción queda configurada y habilitada. Es muy importante siempre limpiar las banderas de interrupción antes de habilitar el bit GIE.

Después de configurar las interrupciones se pasa al programa principal que lo único que hace es poner a 1 todos los pines del puerto A, esperar medio segundo, poner a 0 todos los pines del puerto A, volver a esperar medio segundo para iniciar de nuevo el ciclo y así el programa se repite una y otra vez. La tarea de encender los leds correspondientes a cada botón queda en manos de la rutina de interupción:

La rutina es muy parecida a la del programa del ejemplo anterior con algunos cambios pequeños. Lo importante en la rutina es que al entrar a la misma se deshabilitan las interrupciones al poner a 0 el bit GIE, con esto evitamos que se produzca otra interrupción mientras se está atendiendo una. Después de hacer eso el programa simplemente identifica la tecla pulsada y enciende el led correspondiente. Ya que se encendió el led la rutina continua hacia la etiqueta SALIDA_ISR donde primero se limpia la bandera de interrupción poniendo a 0 el bit RBIF y después se vuelve a habilitar la interrupcion poniendo a 1 el bit GIE, ambos del registro INTCON. Para terminar la rutina y regresar al programa principal se utiliza la instrucción retfie (RETurn From IntErruption). La rutina de servicio de interrupción siempre debe terminar con esa instrucción.

Por último una imágen del diseño esquemático de este ejemplo:

Descargar código: Manejo de interrupciones.

Para mayor información sobre el uso y configuración de interrupciones y los registros de configuración consulta las hojas de datos proporcionadas por Microchip: 16f628a, 16f877a.

Ya hace casi un mes y medio desde la última entrada, había estado ocupado con la escuela y por esa razón dejé un poco de lado este proyecto, pero ahora para continuar un poco por donde íbamos vengo con una nueva entrada, ahora sobre leer botones e interruptores.

Los botones e interruptores son dispositivos que nos sirven para introducir datos a algun sistema eléctrico o electrónico. Leer botones (e interruptores) es una tarea muy sencilla, solamente hay que tener en cuenta que estos, al ser dispositivos mecanicos, no cierran (ni abren) instantaneamente sino que presentan un fenomeno conocido como rebote, que no es otra cosa mas que un ruido electrico que genera errores en al detectar que se presionó un botón y que hace que parezca que el botón se presiono muchas veces.

Teniendo en cuenta eso podemos programar algunas rutinas anti-rebotes con el pic. Dos maneras sencillas de lograrlo son: crear un ciclo para verificar el estado de un bit y no salir de este hasta que el estado sea estable; o verificar el estado de un bit, llamar a un retardo (de alrededor de 10ms, aunque este retardo depende del tipo de interruptor y no es un valor fijo) y despues volver a verificar el estado del bit, si el estado es el mismo entonces el boton se presiono.

Para el primer ejemplo vamos a utilizar el primer tipo de anti-rebote. Tenemos conectado un push-button al pin 0 del puerto A (RA0) y ocho leds al puerto B (RB0 a RB7). Para conectar el push-button se utiliza una resistencia de pull-up de 4.7k (es decir una resistencia de 4.7k conectada a Vcc), el push-button se conecta de un lado a la resistencia de pull-up y del otro a tierra de modo que el pic siempre estará leyendo un 1 lógico y al presionar el botón el estado cambiará a un 0 lógico. El programa consiste en llevar la cuenta de cuantas veces se ha presionado el botón, misma que se desplegará en el puerto B del pic, cada vez que se presione el botón la cuenta se incrementará. El codigo es el siguiente:

Lo único nuevo aqui es la rutina que detecta que se presiona el botón y  la rutina que elimina el rebote. Para detectar que se presionó el botón se está revisando el estádo del pin 0 del puerto A con la instrucción btfsc, mientras el estado del pin sea 1 la ejecución del programa quedará ciclada en el mismo punto, una vez que el estado cambia a 0, es decir se presionó el botón, el programa salta a la rutina antirrebote. Esta rutina lo que hace es permanecer ciclada hasta que el estado del pin de nuevo sea 1, de este modo se eliminan los rebotes. Una vez que sale de la rutina antirrebotes incrementa la cuenta incrementando el puerto B y de nuevo regresa a checar el botón. Ésta es una imágen del circuito esquemático:

Ahora veamos otro ejemplo, esta vez se conectarán 4 push-buttons en el nibble bajo del puerto B y 4 leds en el nibble alto de modo que al presionar un botón se encienda el led correspondiente. Para eso se configura el nibble bajo del puerto como entrada y el nibble alto como salida. Las rutinas de chequeo de botón y de antirrebotes ahora cambian ya que se tienen que revisar cuatro botones. El código del programa principal cambia de la siguiente manera:

El programa va checando botón a botón para saber cual se presionó, una vez que detecta que uno fue presionado llama a la rutina antirrebotes, luego llama a la rutina que enciende el led correspondiente y al regresar continua checando los botones. El circuito esquemático es el siguiente:

Estos dos ejemplos tambien servirían si se usan interruptores en lugar de botones, utilizando el mismo código o efectuando alguna pequeña modificación, sobre todo en la rutina antirrebotes. Para el otro tipo de antirrebotes, en el que se utiliza un retardo, se eliminaria la rutina incluida en estos dos ejemplos ya que al momento de detectar el cambio de estado lógico se debe llamar a una rutina de retardo (como ya se dijo de aproximadamente 10ms) y después volver a comprobar el estádo, si sigue siendo el mismo entonces el botón fue presionado, si no es el mismo entonces la detección fue erronea y no se toma en cuenta.

Por ahora es todo, en proximas entradas hablaré sobre las interrupciones del pic, comenzando por las interrupciones externas del puerto B. Por el momento el código de estos dos ejemplos no se puede descargar, espero solucionar ese problema pronto.

Este es un pequeño tutorial para todos aquellos que utilicen Linux y se vean en la necesidad de usar el ambiente de desarrollo MPLAB. Está basado en una excelente guía de William Spinelli (Installing MPLAB on Ubuntu 6.06) con algunas pequeñas correcciones. La instalacion de MPLAB se hara a traves de Wine y WineTools, se instalara la version 7.31 (aun no he probado si la version 7.50 o 7.51 se pueden instalar mediante este proceso) en la version 6.06 de Ubuntu.

Instalar Wine

Como la version de Wine que se encuentra en el repositorio (0.9.12) no soporta la instalacion de Internet Explorer 6 (IE6) usando WineTools, la instalacion se hace en dos pasos: primero se instala una version antigua de Wine (0.9.8) y despues se actualiza a la ultima version disponible.

Primero se debe instalar la version antigua de Wine
 $ wget http://umn.dl.sourceforge.net/sourceforge/wine/wine_0.9.8-winehq-1_i386.deb
 $ dpkg -i wine_0.9.8-winehq-1_i386.deb

y los siguientes paquetes
 $ sudo apt-get update
 $ sudo apt-get install xdialog cabextract

Despues se debe instalar WineTools manualmente ya que no se encuentra en los repositorios
 $ mkdir winetools; cd winetools
 $ wget http://www.openoffice.de/wt/winetools-0.9jo-III.tar.gz
 $ tar -xzvf winetools-0.9jo-III.tar.gz
 $ cd winetools-0.9jo-III
 $ sudo ./install

Una vez instalado se debe editar el archivo “wt0.9jo” y cambiar el mirror de las fuentes ya que no funciona en la version actual de winetools. El archivo se puede editar con cualquier editor de texto. Editar el archivo
 $ sudo gedit /usr/local/winetools/wt0.9jo

y reemplazar la siguiente linea
[ "$SFMIRROR" = "" ] && SFMIRROR=”http://puzzle.dl.sourceforge.net/sourceforge”

por
[ "$SFMIRROR" = "" ] && SFMIRROR=”http://umn.dl.sourceforge.net/sourceforge”

Habiendo hecho eso se debe ejecutar winetools. Para eso se inicia (como un usuario normal, no como root!) con el siguiente comando
 wt

Para configurar Wine se debe seguir la secuencia exacta de WineTools. En Configuracion Base (Base Setup) se hace en secuencia:

• Crear un disco falso de windows (Create fake windows drive)
• Instalar las fuentes Arial (TrueType Font Arial)
• Installar DCOM98

Despues de eso se debe instalar el archivo MFC4 dll (Microsoft Foundation Classes 4.X), sin embargo el instalador de winetools no funciona, si se instala desde el menu aparecera un mensaje que diga que el archivo ya esta instalado pero no es asi por lo que se deben descargar e instalar manualmente los archivos mfc40.dll y mfc42.dll. Una vez descargados se deben copiar a .wine/drive_c/windows/system32/ pero en minusculas. Despues se vuelve a ejecutar winetools (wt) y se instala IE6

• Internet Explorer 6.0 SP1 Spanish

Una vez hecho eso ya tenemos Wine totalmente configurado asi que ahora se actualiza a la ultima version de Wine. Se edita la configuracion de APT
 $ sudo vi /etc/apt/sources.list
Y se añade el repositorio de Wine HQ:
## repositories for Wine HQ
deb http://wine.sourceforge.net/apt/ binary/
deb-src http://wine.sourceforge.net/apt/ source/

Se actualiza el paquete con
 $ sudo apt-get update
 $ sudo apt-get upgrade

Instalar MPLAB v7.31

Teniendo Wine configurado la instalacion de MPLAB en linux resulta igual de sencilla que si se hiciera en windows. Se descarga el archivo MP731_Full.zip del servidor de Microchip y despues se descomprime
 $ mkdir mplab731; cd mplab731
 $ wget http://ww1.microchip.com/downloads/en/DeviceDoc/MP731_Full.zip
 $ unzip MP731_Full.zip

Y se instala utilizando Wine
 $ wine MP731_full_install.exe
Se sigue el proceso de instalacion (el mismo que en windows) y al finalizar ya se tiene un MPLAB instalado y listo para usarse.

Para terminar simplemente se agrega un scrip de inicio en algun lugar del path de linux. Se crea el archivo mplab
 $ sudo gedit /usr/local/bin/mplab

y se escribe en el
#!/bin/bash
. findwine
$WINE “c:\\Program Files\\Microchip\\MPLAB IDE\\core\\MPLAB.exe” $@ &>/dev/null &

Se hace ejecutable
 $ sudo chmod 755 /usr/local/bin/mplab

Y listo, para iniciar MPLAB simplemente se ejecuta el codigo mplab.