El algoritmo de booth es un algoritmo que sirve para multiplicar (y dividir) números binarios con signo de manera rápida y sencilla en complemento a dos. Aqui explico de manera detallada el funcionamiento de ese algoritmo y muestro una implementacion del mismo para microcontroladores PIC.

La manera en que se representan los números binarios negativos es mediante su complemento a dos. El complemento a uno consiste en invertir el valor de cada bit, esto es que si se tiene el número 5 binario b’00000101′ su complemento a uno sería b’11111010′. Una vez teniendo el complemento a 1 para obtener el complemento a dos simplemente se le debe sumar un 1, asi que se tiene b’11111010 + 1′ de modo que el complemento a dos del número 5 binario es b’11111011′.

Ese es un dato muy importante ya que de ese modo se representan los números binarios negativos y el complemento a dos es parte del algoritmo de multiplicación de Booth. También es importante explicar que utilizando números de 8 bits el número mayor que se puede representar en complemento a dos es 127 y -127 que en binario son b’01111111′ y b’1000001′ respectivamente.

En ensamblador MPASM la manera de obtener el complemento a dos de un número es:
comf NUM,f
incf NUM,w
movwf NUMC2

donde NUM es el registro en el que se encuentra el número que se quiere pasar a complemento a dos y NUMC2 es el registro donde se guarda el complemento a dos del número. Hasta ahí todo bien, ahora pasemos al algorítmo.

Supongamos que queremos multiplicar dos números de 8 bits, digamos que queremos multiplicar 5*(-6) donde 5 es el multiplicando y -6 es el multiplicador, con esos datos se forman 3 arreglos distintos de la siguiente manera:

A=0000 0101 0000 0000 0
S=1111 1010 0000 0000 0
P=0000 0000 1111 1010 0

El byte superior de A está formado por el multiplicando, el siguiente byte se forma con ceros y se agrega un bit extra que también es 0.

El byte superior de S está formado por el complemento a dos del multiplicando, el siguiente byte al igual que el caso anterior se forma con ceros y al final se agrega un bit extra que es 0.

El byte superior de P está formado por ceros, el siguiente byte es el valor del multiplicador y por ultimo se tiene el bit extra.

Se puede observar que los tres números formados son de 17 bits cuando los números que se van a multiplicar son de 8 de modo que los números formados siempre serán de N+1 bits, siendo N el número de bits de los factores.

Sigamos entonces. Este algorítmo consiste en comparar los últimos dos digitos del número P y dependiendo de el caso que sea realizar un suma o no realizar ninguna acción. Luego de evaluar cada caso se debe realizar un corrimiento a la derecha, manteniendo el valor del bit más significativo y desechando el valor del bit menos significativo. Los cuatro casos que se tienen se pueden ver en la siguiente tabla:

0 0 -> No realizar ninguna acción
0 1 -> P = P + A
1 0 -> P = P + S
1 1 -> No realizar ninguna acción

Veamos el algoritmo paso a paso usando los numeros A, S y P de arriba. Primero tenemos el numero P original:

0000 0000 1111 101[0 0] P

Se comparan los ultimos dos digitos [0 0] con los cuatro casos posibles y se ve que no se debe realizar ninguna accion por lo que en la primer iteracion simplemente se realiza un corrimiento a la derecha:

1.
0000 0000 0111 110[1 0] ->

Ahora los ultimos dos digitos [1 0] indican que se debe realizar la suma P=P+S y despues el corrimiento a la derecha:

2.
1111 1011 0111 110[1 0] P=P+S
1111 1101 1011 111[0 1] ->

Despues del corrimiento los ultimos dos digitos son [0 1] por lo que se debe realizar la suma P=P+A y despues el corrimiento a la derecha:

3.
0000 0010 1011 111[0 1] P=P+A
0000 0001 0101 111[1 0] ->

Ahora los ultimos dos digitos son [1 0], se realiza la suma P=P+S y despues el corrimiento a la derecha:

4.
1111 1100 0101 111[1 0] P=P+S
1111 1110 0010 111[1 1] ->

Los ultimos dos digitos [1 1] al igual que cuando fueron [0 0] indican que solo se debe realizar el corrimiento a la derecha:

5.
1111 1111 0001 011[1 1] ->

De nuevo se tiene [1 1] por lo que se realiza unicamente el corrimiento y en lo sucesivo se tendra siempre el mismo caso:

6. 1111 1111 1000 101[1 1] ->
7. 1111 1111 1100 010[1 1] ->
8. 1111 1111 1110 0010 [1] ->

Despues de 8 iteraciones termina el algoritmo, se desecha el bit menos significativo (el bit extra) y se obtiene el producto de la multiplicacion:
5*(-6) = 1111 1111 1110 0010 = -30

Cabe mencionar que el numero de iteraciones que realiza el algoritmo es igual N, que es el numero de bits de los factores y el resultado final es igual a 2N, en este caso se multiplican factores de 8 bits por lo que el resultado final es de 16.

Esta es la manera en la que funciona el algoritmo. Solamente hay que tener en cuenta que al realizar los corrimientos a la derecha se debe mantener siempre el bit mas significativo, esto es que si se tiene ‘1101′ y se realiza el corrimiento el resultado sera ‘1110′ y no ‘0110′.

Implementacion del algoritmo de Booth en MPASM

Aplicando los pasos que acabo de explicar realice una implementacion del algoritmo de Booth para la multiplicacion en MPASM para realizar multiplicaciones de numeros signados de 8 bits en microcontroladores PIC 16F.

El algoritmo implementado sigue los mismos pasos descritos, compara los ultimos dos digitos del factor P y realiza alguna de las acciones posibles para despues llevar acabo el corrimiento. Como mencione en un principio el algoritmo solo puede multiplicar numeros que van del -127 al 127 y el resultado lo da a traves de los registros RESULTADOH:RESULTADOL.

Para poder utilizar esta rutina (multibooth) se deben declarar los registros A1, A2, A3, S1, S2, S3, P1, P2, P3, MULTIPLICANDO, MULTIPLICADOR, RESULTADOH, RESULTADOL y CONT.

En los registros RESULTADOH:RESULTADOL se muestra el valor positivo del resultado y si este fuera negativo se activa la bandera SIGNO (bit 0 del registro A3) para indicar que se trata de un numero negativo.

Una vez explicado el algoritmo creo que no hay necesidad de explicar la implementacion de la rutina aunque si asi fuera siempre estan los comentarios para exponer y aclarar las dudas.

Espero que esto les sirva.

Descargar codigo: Multiplicacion mediante el algoritmo de Booth

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.

Después de un tiempo desaparecido regreso con una rutina para controlar un teclado matricial 4×3 con un pic 16F628A. Esta rutina es una adaptación de la rutina original del Teclado Matricial 4×4 hecha por petición popular (ok, un solo comentario, pero alguien lo pidió). La lógica del manejo del teclado matricial 4×3 es la misma que para el teclado 4×4, el nibble bajo del puerto B se configura como salida y el nibble alto como entrada. Se recorre un cero por el nibble bajo y se va incrementando un puntero que es el que nos ayuda a saber exactamente que tecla se presionó.

Como este teclado cuenta con solo 12 teclas, el puntero llegará hasta 12 y si no se presionó ninguna tecla para entonces la rutina que explora el teclado volverá a empezar. En realidad la lógica es la misma que para el teclado matricial de 16 teclas, así que si desean leer la explicación completa lo pueden hacer en la página del teclado matricial 4×4.

Este es el diagrama de conexión del teclado en un pic 16f628a.

Descargar el código: Teclado Matricial 4×3.

Con esto vuelvo después de unos meses, espero no tardarme tanto para volver a actualizar el blog. Como siempre sus comentarios son bien recibidos y se aceptan sugerencias para futuros tutoriales.

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

Un teclado matricial es un simple arreglo de botones conectados en filas y colúmnas, de modo que se pueden leer varios botones con el mínimo número de pines requeridos. Un teclado matricial 4×4 solamente ocupa 4 lineas de un puerto para las filas y otras 4 lineas para las colúmnas, de este modo se pueden leer 16 teclas utilizando solamente 8 líneas de un microcontrolador. Si asumimos que todas las columnas y filas inicialmente están en alto (1 lógico), la pulsación de un botón se puede detectar al poner cada fila a en bajo (0 lógico) y checar cada columna en busca de un cero, si ninguna columna está en bajo entonces el 0 de las filas se recorre hacia la siguiente y así secuencialmente.

Un modo simple de detectar la tecla presionada es incrementar una variable con la cuenta de las teclas revisadas, de este modo al detectaruna pulsación el valor de la cuenta será el valor de la tecla presionada. Si al final no se presionó ninguna tecla la variable se pone a cero y la cuenta vuelve a comenzar. El puerto B del microcontrolador 16f628 (así como en el 16f877) viene preparado especialmente para el control de un teclado matricial 4×4. Para tener siempre un valor de 1 lógico en las colúmnas del teclado (parte alta del puerto B del pic) es necesario conectar resistencias de pull-up, sin embargo el puerto B cuenta con resistencias de pull-up integradas, de ese modo es posible trabajar con un teclado matricial sin necesidad de ningún componente externo.

Las resistencias de pull-up del puerto B se habilitan poniendo en 0 el bit NOT_RBPU del registro OPTION_REG.Al método aqui expuesto para detectar la pulsación de una tecla en un teclado matricial se le conoce como muestreo secuencial. Existen otros, sin embargo esté es tal vez el más sencillo. En el siguiente ejemplo cada tecla del teclado matricial tiene un valor de 0 a F, valor que se despliega en un display de 7 segmentos. El el código necesario para leer un teclado matricial con un microcontrolador pic 16f628 es el siguiente.

Programa principal:

El programa principal es muy sencillo, simplemente configura el puerto A como salida, la parte baja del puerto B también como salida y la parte alta del puerto B como entrada. Además de configurar los puertos también se habilitan las resistencias de pull-up internas con la línea bcf OPTION_REG,NOT_RBPU. Después de la configuración se llama a una rutina llamada TECLADO encargada de escanear el teclado y regresar el valor de la tecla pulsada para poder desplegar el número correspondiente en un display de 7 segmentos y el programa ahí se queda en un ciclo llamando a la rutina TECLADO y después desplegando y repitiendo lo mismo cíclicamente.La rutina TECLADO escanea el teclado matricial usando el método que ya se mencionó.

Primero se carga un 0 a la primer fila, después se checa columna a columna si hay un cero, en caso de que no se detecte ningún cero, el cero de las filas se recorre y se vuelven a revisar las columnas. Si no se detectó ningún cero significa que no se presionó ninguna tecla y la rutina vuelve a comenzar. Si se detectó un cero significa que se presionó una tecla y en ese momento la salta a la rutina ANTIRREBOTES. Después de eliminar los rebotes se decodifica la tecla pulsada utilizando una tabla como la que se utilizó en el ejemplo del display de 7 segmentos.

Existen otros métodos de manejar teclados matriciales, pero creo que ésta es la más sencilla. Para terminar una imágen del circuito:

Descargar el código: Teclado Matricial 4×4.

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.

Un display de 7 segmentos no es otra cosa que 7 leds conectados entre si con su ánodo o su cátodo en común. Dependiendo del tipo de display será la manera en que se enciendan sus segmentos, un display de cátodo común requiere un 1 logico para encender mientras que uno de cátodo común un 0 así que dependiendo del display que se utilice cambiará la rutina encargada de controlarlo, pero en cualquier caso al momento de cambiar el tipo de display solo debemos cambiar los ceros por unos y viceversa.

Aqui supondremos que se usa un display de cátodo común así que los segmentos encenderán con un 1. El display estará conectado al puerto B, el segmento A estará conectado al bit RB0, el B al RB1, el C al RB2, el D al RB3 y así sucesivamente hasta llegar al G que estará conectado al bit RB6.

Encender y apagar los segmentos del display es igual que encender y apagar leds, podríamos hacerlo de la misma manera que en el tutorial 1, pero una manera mas eficaz de controlar un display es mdiante una tabla. Haremos que el display muestre los números 0 a 15 en hexadecimal (0 a F) con un retardo de medio segundo entre cada número. Para eso se declara el puerto B como salida. Una vez hecho eso se crea la rutina encargada de mandar llamar el numero correspondiente de una tabla y de desplegar el numero correspondiente por el puerto B. El programa principal es el siguiente:

Y ese es basicamente el programa. Al principio se declaran 4 variables, una se utiliza para llevar la cuenta del numero a desplegar y las demas sirven para la rutina de retardo. Como ya se dijo se configura el puerto B como salida y despues se limpia la variable Numero (clrf NUMERO). Despues el programa entra en una subrutina que se encarga de leer la tabla y de desplegar el numero en el puerto. Primero se mueve el valor de la variable Numero al registro W (movf NUMERO,w) y despues se manda llamar la tabla (call DESPLIEGA), al volver el registro W tiene el valor del numero a desplegar y simplementa se mueve al puerto B (movwf PORTB). Se llama a la rutina de retardo (call RETARDO) y al volver de esta se incrementa el valor de la variable Numero (incf NUMERO,f) y despues se transfiere ese valor al registro W (movf NUMERO,w). Esto se hace para realizar una comparacion entre W y la literal 0×10 (16 en valor decimal) para saber si la variable Numero ya fue incrementada 16 veces, si es asi se salta la siguiente instruccion y el programa se repite desde la etiqueta Principal, si no es asi el programa regresa a la etiqueta Ciclo. De este modo el numero se incrementa de 0 a F y al llegar a F regresa a 0. La comparacion se realiza mediante la instruccion sublw 0×10 si el resultado es cero (en caso de que NUMERO=16) la bandera ZERO se pone en 1 y es esa la bandera que se revisa en btfss STATUS,Z.

Como ya se dijo antes de llamar la rutina que lee la tabla se carga el valor de la variable Numero en W, esto se hace asi ya que al entrar a la rutina se realiza una suma entre W y el contador de programa PCL para montarlo en un offset, asi el contador apuntara a la direccion que seguia mas el valor de la variable Numero. Asi la rutina de la table queda de la siguiente manera:

Y asi, de este modo se decodifica un display de 7 segmentos. La rutina de retardo se omitio en la explicacion ya que los retardos se explicaron anteriormente, de cualquier forma se incluye en el codigo del programa. Descargar codigo.

Como nota final: Las imagenes que contienen el codigo en esta ocasion se ven algo distintas que en los tutoriales pasados, ese descuadre se debe a que el codigo se escribio utilizando MPLAB bajo linux, pero en realidad se conservan los mismos espacios y tabulaciones que en ocasiones anteriores, eso se puede ver al descargar el codigo completo.