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.

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.

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.