Un nuevo proyecto que tengo entre manos es la creación de un libro-manual de sistemas digitales para todos aquellos nuevos en el mundo digital, donde se pueda aprender sobre compuertas lógicas y álgebra de Boole, lógica combinatoria y secuencial e incluso, siendo un poco ambicioso, sobre diseño de microprocesadores.

Como explico en la página del proyecto, Digitales-desde-cero aún se encuentra en una etapa (mucho) muy temprana de su desarrollo pero bueno, siempre es bueno decir en voz alta este tipo de proyectos porque así ya se tiene la presión de saber que ya se habló de mas y que ahora más vale presentar algun producto y mucho mejor si es un buen producto que eso espero que sea.

Bueno, ya está dicho, todo aquel que quiera aprender sobre sistemas digitales dentro de algún tiempo podrá hacerlo, aunque antes de que el libro este terminado iré publicando algunas partes y capítulos, de cualquier manera no publicaré ninguno muy pronto pero aqui queda la promesa de publicar un libro.

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.

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

Hace un año ya que este blog le decía por primera vez hola al mundo y lo hacía con la intención de convertirse en un lugar de referencia para todo aquel que quisiera comenzar en este mundo de los microcontroladores PIC. Ha pasado ya un año y creo que para más de uno este sitio si ha servido de ayuda.

Durante este primer año este blog tuvo más de 100,000 visitas, una cifra que puede no parecer muy impresionante pero que a mi si me impresiona, más de 100,000 personas interesadas en los microcontroladores que han leido mis tutoriales y ejemplos, y muchos de ellos hasta han hecho comentarios. Espero, imitando un poco al teletón, que esa cifra se supere para el 10 de enero del 2009.

Y para cerrar este post de aniversario debo hacer mención al post que ha sido la estrella del blog, el tutorial sobre MPLAB, el tutorial mas visto y el que ha tenido mayor éxito, aunque el reciente sobre multiplexacion de leds se encamina a convertirse también en un clásico. En aquella ocasión prometí realizar un tutorial sobre como simular los programas utilizando la herramienta MPSIM y ese tutorial aún no aparece pero me comprometo a realizarlo pronto, tal vez para el 22 de enero que cumpla un año el tutorial de MPLAB.

Ahora si esto es todo, muchas gracias a ustedes que visitaron este blog, espero que durante este año lo continúen haciendo, aún faltan muchos temas por tratar así que no se los pierdan. Muchas gracias y aqui nos veremos el 10 de enero de 2009 cumpliendo un año más.

En esta ocasión les traigo la librería para los pics 16f627, 16f627a, 16f628, 16f628a y 16f648a para EAGLE Layout Editor. Al igual que las librerías anteriores esta es una primera versión que solamente incluye el encapsulado PDIP de 18 pines, en futuras acutalizaciones incluiré los demás encapsulados.

También anuncio que todas las librerías que vaya creando estarán disponibles en la página http://thestardestroyer.googlepages.com/libreriaseagle.html así que aunque seguiré publicandolas en este blog no dejen de visitar aquella página para ver las nuevas actualizaciones de las librerías. Hasta pronto.

Descargar: pic16f6xx-v0.1.lbr

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.

2007 está a unas horas de terminar y no está de más hacer una pequeña reflexión de lo que fue este 2007. Comencé este blog el 10 de enero de este año con la intención de crear un espacio donde pudiera compartir conocimiento y aprender más sobre microcontroladores PIC, el año hoy termina y creo que este blog logró cumplir su propósito.
Aprovecho también para darle las gracias a todos ustedes que han leido lo que he publicado, que han dejado sus comentarios y lo más importante: que han utilizado mis ejemplos en sus propios proyectos y aplicaciones. Muchas gracias a todos ustedes y despido este año con la promesa de seguir trabajando en este blog ya que aún faltan muchos temas por tratar, y para este 2008 mi propósito será actualizar este sitio de manera más regular.

Les deseo un feliz 2008, que todos sus propósitos se cumplan y que todos sus proyectos funcionen, nos vemos el próximo año y no olviden volver a visitar esta página, además el 10 de enero se cumple un año así que veré si preparo una sorpresa.

Ayer publiqué la librería para microcontroladores pic 16F88x, ahora hago lo mismo para los pic 16F87 y 16F88 para poder utilizarlos en Eagle Layout Editor. Esta es la versión 0.1 y solamente se encuentra el paquete DIP y SOIC de 18 pines pero posteriormente la actualizaré para incluir SSOP y QFN.

Sin más por el momento aqui dejo la librería
Descargar: pic16f88-v0.1.lbr

El Eagle Layout Editor es un programa muy potente para crear diagramas esquemáticos y circuitos impresos de manera sencilla. Su uso está muy extendido por lo que no resulta difícil encontrar entre sus librerías el componente que se necesita en un circuito, sin embargo hay casos que aquel componente que se ocupa no se encuentra en ninguna librería como pueden ser algunos microcontroladores PIC.

Ultimamente he dejado este blog abandonado, la razón es que he estado ocupado desarrollando un proyecto utilizando un pic 16F886, la programación ya quedó lista y ahora pretendía realizar el circuito impreso cuando me di cuenta que dentro de las librerías del Eagle no se encontraba ese pic. CadSoft cuenta con una página donde se pueden descargar librerías para su programa, además buscando en google se pueden encontrar muchas más pero no me fue posible encontrar una que incluyera el pic que necesitaba por lo que decidí crear la librería yo mismo.

Crear componentes y librerías para Eagle es muy sencillo, al principio puede ser algo tedioso pero con un poco de práctica las cosas se hacen más rápido. Para crear la librería seguí el tutorial Eagle Library Design y el resultado fue la librería pic16f88x-v0.1.lbr.

Comparto este archivo para que cualquiera que necesite crear un circuito en Eagle utilizando los pics 16F882, 16F883, 16F884, 16F886 y 16F887 lo pueda hacer sin problemas, esta es la primer versión y espero mejorarla en un futuro así como también crear librerías para otros microcontroladores PIC. Como es la primer versión es posible que exista algún error así que si alguien detecta uno por favor hagamelo saber.

Aquí dejo esta librería, lo pueden tomar como un regalo atrasado de navidad o uno adelantado de reyes pero como sea espero que les sea de utilidad.

Descargar: pic16f88x-v0.1.lbr

Por mucho, el post más popular de este blog es en el que explico la instalación y uso de MPLAB. Sin duda porque es un entorno de desarrollo muy potente que permite escribir, ensamblar, simular y programar los pics, todo desde el mismo programa. En linux no existe una herramienta tan poderosa, es por eso que muchos instalan MPLAB en este sistema operativo.

Una buena alternativa a MPLAB en linux puede ser Piklab, un entorno de desarrollo para microcontroladores pic que se integra con muchos compiladores y ensambladores y con un simulador llamado GPSim, y que además permite programar los pics con los programadores más comunes.

Piklab está programado para el entorno de escritorio KDE, por lo que para instalarlo en una distribución como Ubuntu (basada en GNOME) es necesario tener las librerías de KDE y QT instaladas. Esto se hace fácilmente mediante apt-get escribiendo en una terminal:

• sudo apt-get install xlibs-dev kdebase-dev

Además de esas librerías es necesario tener instaladas dos librerías más, de modo que de nuevo en una terminal se escribe:

• sudo apt-get install libusb-dev libreadline5-dev

Después de eso ya podemos instalar Piklab, pero primero lo debemos descargar de la siguiente dirección
http://piklab.sourceforge.net/download.php
Para Ubuntu no existe un binario para instalarlo (como si es el caso de otras distribuciones como Slackware) así que tendremos que descargar las fuentes y compilar el programa. Para eso hacemos click en Download Piklab y después descargamos el paquete *.tar.bz2

Una vez descargado lo descomprimimos. Se puede descomprimir usando el gestor de archivos comprimidos o descomprimiendolo desde la terminal, yo prefiero la segunda opción, así que en la terminal nos vamos al directorio donde se haya descargado el archivo y lo descomprimimos:

• tar -xvf piklab-*.tar.bz2
• cd piklab*

Una vez dentro del directorio con los archivos fuente procedemos a compilar el programa. Eso es algo muy sencillo aunque dependiendo del tipo de máquina puede ser más o menos lento, y simplemente se utilizan 3 comandos: configure, make y make install, de la siguiente manera:

• ./configure
• make
• sudo make install

Una vez hecho eso Piklab está instalado y casi listo para usarse, solamente falta instalar unas herramientas que nos permitan ensamblar y compilar nuestros archivos en ensamblador desde Piklab, estas herramientas son GPUTILS y se encuentran disponibles en los repositorios de Ubuntu así que fácilmente se instalan vía apt-get:

• sudo apt-get install gputils

Y listo, ahora si podemos iniciar Piklab (desde el menú Aplicaciones -> Programación -> Piklab o ejecutando el comando piklab). Por último una captura de este entorno de desarrollo.

Esta guía en parte está basada en el tutorial Instalando Piklab en Ubuntu de Cosas de Mecatrónica.