sábado, 14 de diciembre de 2013

Aprendiendo a programar PICs en BASIC

Introducción

¡Aprende BASIC!


¡Aprende BASIC!
Esta guia o tutorial esta dedicada al lenguaje de programación PIC BASIC incluido en el PIC SIMULATOR IDE, y puede ser útil para aquellos que están aprendiendo a utilizar otros dialectos de BASIC de microcontroladores, como PIC BASIC PRO (PBP) o PROTON, ya que se parecen mucho.
NOTA: Este artículo forma parte de la Revista uControl Numero 1, Numero 2 y Numero 3.

Variables

Vamos a comenzar a ver algo de la programación en el BASIC incluido en el entorno PIC SIMULATOR IDE, al que en adelante nos referiremos como "BASIC", a secas.
La programación seria prácticamente imposible sin el uso de variables. Podemos hacernos una imagen mental de las variables consistente en una caja en la que podemos guardar algo. Esa caja es una de las muchas que disponemos, y tiene en su frente pegada una etiqueta con su nombre. Estas cajas tienen ciertas particularidades, que hace que solo se puedan guardar en ellas determinados tipos de objetos.
En esta analogía, cada caja es una variable, su contenido es el valor que adopta, y la etiqueta es el nombre de la variable. Como su nombre lo indica, y como veremos mas adelante, el contenido de una variable puede ser modificado a lo largo del programa.

Tipos

En BASIC tenemos distintos tipos de variables, según el dato que puedan almacenar:


  • Bit (un bit de longitud, almacena 0 o 1 únicamente)
  • Byte (un byte de longitud, almacena números enteros entre 0 y 255)
  • Word (dos bytes de longitud, almacena números enteros entre 0 y 65,535)
  • Long (cuatro bytes de longitud, almacena números enteros entre 0 y 4,294,967,295)

El tipo "Long" solo esta disponible mediante un modulo opcional al PIC SIMULATOR IDE. A diferencia de otros BASIC, la declaración de variables puede ser hecha en cualquier parte del programa, y todas son consideradas globales, es decir, su valor es accesible desde todas las subrutinas y zonas del programa. El numero de variables esta lógicamente limitado al monto de memoria RAM disponible en cada microcontrolador.



DIM

Las variables deben ser declaradas antes de utilizarlas, mediante la instrucción DIM, como se muestra en los siguientes ejemplos:

 DIM A AS BIT
 DIM B AS BYTE
 DIM X AS WORD
 DIM Y AS LONG
 
También es posible utilizar vectores, que son una matriz de dimensiones 1xN . Por ejemplo, la sentencia siguiente:

 DIM A(10) AS BYTE
 
declara un vector (al que nos referiremos algunas veces como "array") de diez elementos del tipo BYTE, que serán accedidos mediante el uso de subíndice (entre paréntesis) del 0 al 9.

Las variables tipo Word, como vimos, están compuestas por dos bytes. el primero de ellos es llamado byte "alto" y el otro "bajo", dado que el primero contiene los 8 bits mas significativos. En BASIC podemos acceder individualmente a cada uno de los bytes que componen un Word mediante las extensiones ".HB" (High byte, o byte alto) y ".LB" (Low Byte o byte bajo).

Veamos un ejemplo:

 DIM A AS BYTE
 DIM B AS WORD
 A = B.HB
 A = B.LB 'Esto es lo mismo que A = B
 B.HB = A
 B.LB = A
 B = A 'Esto también borra el byte alto de la variable B
 
Los bits individuales de cada variable pueden ser accedidos individualmente también, simplemente poniendo como extensión ".n" donde "n" es el numero de bit (1,2, 3, etc. )

 DIM A AS BYTE
 DIM B AS BIT
 B = A.1
 B = A.7
 A.0 = A.5 



RESERVE

La sentencia RESERVE le permite al programador reservar un numero de posiciones de la RAM para su uso en rutinas en assembler o para el In-Circuit Debugger de MPLAB. Simplemente, si queremos reservar 20 bytes de RAM, escribimos:

 RESERVE 20

Puertos

Todos los registros del microcontrolador esta disponibles para usar en los programas BASIC, como si se tratase de variables del tipo BYTE con el nombre del registro utilizado en las datasheet (PORTA, PORTB, TRISA, etc.). Por supuesto, se puede acceder a bits individuales de los registros con la técnica vista párrafos atrás. Algunos ejemplos:

 TRISA.1 = 0
 TRISB = 0
 PORTA.1 = 1
 PORTB = 255
 STATUS.RP0 = 1
 INTCON.INTF = 0
 
Existe una "forma corta" de acceder a los bits individuales de cada port, simplemente usando las variables BASIC tipo byte RA, RB, RC, RD, RE o bien las tipo bit RA0, RA1, RA2, ..., RE6, RE7


 RA = 0xFF
 RB0 = 1

Punteros

En BASIC también podemos usar punteros. En realidad, cualquier variable definida como tipo BYTE o WORD pude ser usada como un putero de memoria, usándola como argumento de la función POINTER. El valor contenido por la variable debe tener un valor comprendido entre 0 y 511.

Ejemplos:

 DIM X AS WORD
 DIM Y AS BYTE
 X = 0x3F
 Y = POINTER(X)
 Y = Y + 0x55
 X = X - 1
 POINTER(X) = Y
 Y = 0xAA
 X = X - 1
 POINTER(X) = Y

SYMBOL

Una forma de escribir programas que nos resulten mucho mas fáciles de entender es el uso de nombres simbólicos, o SYMBOL. Un "symbol" es una cadena que contiene código, asignado a un nombre. Al momento de compilar, PIC BASIC hace la "búsqueda y reemplazo" de nuestros símbolos y luego genera el código ASM y el HEX. Supongamos que tenemos un LED conectado al bit cero del puerto B. Mediante SYMBOL podemos hacer:
 
 SYMBOL LED1 = PORTB.0
 
Luego, si queremos encender el LED, en lugar de

 PORTB.0 = 1
 
podemos hacer

 LED1 = 1
 
que es mucho mas claro y fácil de leer. Por supuesto, el código que aparece a la derecha del igual no puede contener instrucciones o comandos.

Las constantes (valores que usamos en nuestro programa, y que, por ejemplo, asignamos a las variables) pueden ser escritas en decimal (directamente el valor), en hexadecimal (anteponiendo "0x" o posponiendo "H" al valor) o en binario (anteponiendo "%" al valor).

Por ejemplo:

 DIM A AS BIT
 DIM B AS BYTE
 A = TRUE
 B = 0x55
 B = %01010101
 
Por supuesto, se pueden asignar nombres a las constantes, usando la instrucción CONST:

 DIM A AS WORD
 CONST PI = 314
 A = PI
 
Hay tres instrucciones para el manejo individual de bits, que si bien no hacen nada que no se puede resolver con otras instrucciones o símbolos, ayudan mucho en la lectura del código. Se tratan de HIGH, LOW y TOGGLE, que ponen el bit en alto, bajo o lo invierten, respectivamente. Importante: Si el bit implicado como argumento de una de estas instrucciones es un bit de un PORT, el mismo bit en el TRIS correspondiente es puesto en cero, y dicho pin queda configurado como salida.

Algunos ejemplos:

 HIGH PORTB.0
 LOW ADCON0.ADON
 TOGGLE OPTION_REG.INTEDG



GOTO

Esta es una de las instrucciones más polemicas que se encuentra en todos los dialectos BASIC. GOTO significa literalmente "IR A", y sirve justamente para eso: desviar el flujo del programa a otro punto.
Para usar GOTO, es necesario poner una etiqueta en el lugar al que queremos "saltar". Las etiquetas son simplemente nombres terminados en ":", tal como se ve a continuación:
 
 ...
 ...
 calculos:
 ...
 ...
 ...
 ...
 ...
 GOTO calculos
 ...
 ...
 
En el ejemplo anterior, el programa se ejecutará hasta encontrar la instrucción "GOTO calculos", que hara que se ejecuten nuevamente las instrucciones siguientes a la etiqueta "calculos:". Cabe aclarar que las etiquetas no son un código ejecutable, es decir, no realizan ninguna acción, solo son un "marcador" del lugar al que se puede saltar con GOTO.

Operaciones Lógicas y Matemáticas

PIC SIMULATOR IDE dispone de cinco operaciones matemáticas básicas, disponibles para las variables tipo Byte y Word. Estas son la suma (operador +), la sustracción (operador -), el producto (operador *), el cociente (operador /) y el módulo (operador MOD) .Por supuesto, el compilador es capaz de combinarlas para obtener operaciones matemáticas mas complejas.


 DIM A AS WORD
 DIM B AS WORD
 DIM X AS WORD
 A = 123
 B = A * 234
 X = 2
 X = (12345 - B * X) / (A + B)

Es posible calcular raíces cuadradas (aunque el resultado debe ser entero) con la función SQR:
 
 DIM A AS WORD
 A = 3600
 A = SQR(A)
 
Para las variables de tipo Bit existen siete operaciones lógicas disponibles. Solo es posible efectuar una operación lógica por instrucción (aunque es muy posible que próximas versiones permitan mas flexibilidad. Este al tanto de las novedades!). Estas operaciones también están disponibles para variables tipo Word o Byte. Veamos algunos ejemplos:


 DIM A AS BIT
 DIM B AS BIT
 DIM X AS BIT
 X = NOT A
 X = A AND B
 X = A OR B
 X = A XOR B
 X = A NAND B
 X = A NOR B
 X = A NXOR B
 DIM A AS WORD
 DIM B AS WORD
 A = A OR B
 PORTB = PORTC AND %11110000



Mi primer programa: Un LED parpadeando

Luego de estos capítulos de introducción, puramente teóricos, vamos a encarar nuestro primer programa. A diferencia de un programa de ordenador, donde uno escribe el programa, lo compila, lo ejecuta y ya, en el mundo de los microcontroladores hay que, previamente, definir el tipo de microcontrolador que se va a utilizar, cual va a ser su frecuencia de clock, como va a ser el circuito en que se va a utilizar el mismo, etc.
Para estas practicas, utilizaremos un PIC16F628A, uno de los mas difundidos y que mas o menos viene a reemplazar al viejo y popular PIC16F84A, ya obsoleto. El diagrama circuital que utilizaremos para las primeras practicas es el siguiente:


Imagen:PSIBASICejemplo1.gif

Si bien se supone que quien esta leyendo este tutorial tiene una buena idea sobre electrónica y microcontroladores (si no, puede leer el resto de uControl), igualmente vamos a hacer una muy breve descripción del circuito.

En primer lugar, vamos a aprovechar el oscilador interno del PIC16F628Ay nos evitaremos el xtal y condensadores asociados. El puerto B del micro (pines 6 al 13) esta conectado a 8 LEDs mediante 8 resistencias de 220ohms, que tienen como función limitar la corriente que circula por los LEDS. Estos serán nuestras "salidas". Los pines 17 y 18, correspondientes al PORTA.0 y PORTA.1 están conectados a sendos pulsadores, que al ser presionados conducen 5V (un "1") al pin respectivo. Cuando están en reposo, las resistencias R1 y R2 se encargan de mantener el pin en "0". Por ultimo, el pin 1 (PORTA.2) comanda un parlante mediante un transistor, para hacer alguna prueba con sonidos.
El circuito debe alimentarse con 5v bien filtrados y regulados.

Volviendo a nuestro programa, vamos a escribir el "hola mundo" de los microcontroladores: encender un LED.

El primer paso es, desde el menú "Opciones" -> "Select Microcontroller", elegir el PIC16F628A.


Imagen:PSIBASIC35.jpg

Luego, debemos configurar los bits correspondientes:


Imagen:PSIBASIC36.jpg

Lo destacable por ahora de esta configuración es que estamos dejando la memoria (FLASH y EEPROM) sin protección, que el pin RESET se va a comportar como I/O y que usaremos como oscilador el oscilador interno INTRC.
Una vez hecho esto, arrancamos el edito de BASIC (presionando CTRL-C, por ejemplo), y escribimos el siguiente código:
 
 AllDigital
 TRISA = %11111111
 TRISB = 000000
 loop:
   PORTB.0 = 1
   WaitMs 500
   PORTB.0 = 0
   WaitMs 500
 Goto loop
 
Vamos a analizarlo línea por línea para entender su funcionamiento:

La línea 001 utiliza la sentencia AllDigital para convertir todos los pines del micro en pines de E/S. Esto equivale a deshabilitar los comparadores, conversores A/D y todos los módulos que pudiese tener nuestro microcontrolador. No es la única manera de hacer esto, pero si la mas sencilla desde el punto de vista del programador BASIC.

Las líneas 003 y 004 convierten todos los pines del puerto A en entradas ( TRISA = %11111111 ) y los del puerto B en salidas ( TRISB = 000000 ). El "%" indica que el numero que viene a continuación esta en binario. Se podría haber escrito, por ejemplo TRISB = 0 y hubiera sido lo mismo. Personalmente me gusta esta manera, ya que "veo" el estado de cada pin. Por supuesto, es valido activar como entrada algunos pines, y como salidas otros, haciendo algo parecido a TRISB = %11000111.

En la línea 006 encontramos una "etiqueta" ( loop: ). Esta no hace nada, solo sirve como referencia para enviar el flujo del programa a esa línea desde otro lugar, mediante la sentencia "Goto".
La línea 007 pone en "1" el pin correspondiente a PORTB.0, de manera que en el pin 6 del microcontrolador habrá 5V. Esta tensión hará que circule una corriente a través de la resistencia limitadora y el LED1, haciendo que este se encienda, ya que el cátodo se encuentra conectado a 0V.

En 008 tenemos la sentencia WaitMs 500 . WaitMs se encarga de hacer una pausa en milisegundos. La duración de la pausa esta dada por el numero que sigue a la instrucción, en este caso 500 milisegundos, o medio segundo.

Luego, en 009, otra vez se vuelve a poner en 0 el pin 6, mediante PORTB.0 = 0 , lo que provoca que ese pin se ponga a 0V, y no haya mas circulación de corriente a través de la resistencia y del LED, con lo que este se apaga.

En 010 se hace nuevamente una pausa de medio segundo, y por ultimo, la línea Goto Loop hace que el programa continúe en la línea 006 (que es donde esta la etiqueta Loop).
El programa se repite indefinidamente, encendiendo el LED medio segundo, apagándolo otro medio segundo.

Si presionamos F9 o vamos al menú que vemos a continuación:


Imagen:PSIBASIC39.jpg

PIC SIMULATOR IDE compilara el programa, y cargara el HEX resultante en el simulador. Aparecerá el cuadro de dialogo siguiente, en donde se nos informa entre otras cosas que no han ocurrido errores, el tamaño del programa (69 words), y la ruta a donde se ubicaron los archivos generados.


Imagen:PSIBASIC38.jpg

Si volvemos a la ventana principal del PIC SIMULATOR IDE, y desde "Tools" -> "Microcontroller View" abrimos la vista del microntrolador, al darle "Start" a la simulación tendremos algo parecido a lo que sigue:


Imagen:PSIBASIC40.jpg

En la captura se puede apreciar que el pin 6, correspondiente a RB0 esta en "ON". Si esperamos lo suficiente, veremos como pasa a "OFF", y mas tarde vuelve a "ON", etc. Si queremos esperar menos tiempo, y esto lo debemos tomar como una regla general al correr simulaciones, podemos disminuir el tiempo indicado en las instrucciones "WaitMS" a valores iguales a 1, de esta manera la simulación será mucho mas ágil. Por supuesto, al momento de llevar el HEX a nuestro microcontrolador en el circuito "real", debemos cambiar a los tiempos originales y volver a compilar. Caso contrario, el LED permanecería encendido solo una milésima de segundo, luego apagado el mismo tiempo, etc., por lo que nuestro ojo lo percibiría como encendido a medias, incapaz de discriminar su verdadero estado.

Se podría haber utilizado la instrucción SYMBOL para hacer mas claro el programa. En el siguiente ejemplo, hemos hecho algunos cambio y obtenido un programa que hace exactamente lo mismo que el anterior, pero que resulta mas claro de entender, ya que se aproxima algo mas al "lenguaje natural":


Imagen:PSIBASIC41.jpg



Mi segundo programa: Usando un pulsador

En la segunda practica del lenguaje BASIC veremos como leer una entrada del PIC. Utilizaremos el mismo esquema que vimos antes, y el programa que mostramos a continuación:

 AllDigital
 TRISA = %11111111
 TRISB = 000000
 loop:
    PORTB.0 = PORTA.0
 Goto loop
 
Como resulta evidente a simple vista, el programa ejemplo2.bas es muy similar al ejemplo1.bas que vimos en el capitulo anterior. Las diferencias están dentro del bucle. La instrucción PORTB.0 = PORTA.0 hace que el valor del bit 0 del PORTB tome el valor del bit 0 del PORTA. Que ambos bits sean el cero es solo una coincidencia, se podrían haber elegido otros valores.

Al ejecutarse el programa, cada vez que se accione el pulsador conectado a PORTA.0, ese pin se pondrá a estado alto, ya que la corriente circulara desde +V al pin 17 del PIC por medio del pulsador. Ese "estado alto" se interpreta dentro del PIC como un "1", y es el valor que se le asigna a PORTB.0 , con lo que el también pasara a estado alto. Eso provocara que el led conectado en ese pin se ilumine.
Cuando soltamos el pulsador, PORTA.0 vuelve a estado bajo, ya que se pone a masa a través de la resistencia de 10K, y PORTB.0 hará lo propio, apagando el LED.

Nuestro sencillo (sencillísimo!) programa todo lo que hace es "copiar" en el LED el estado del pulsador.
Si presionamos F9 o vamos al menú que vemos a continuación


Imagen:PSIBASIC42.jpg

PIC SIMULATOR IDE compilara el programa, y cargara el HEX resultante en el simulador. Aparecerá el cuadro de dialogo que nos informa que no han ocurrido errores y que el tamaño del programa esta vez es de 20 words.
 
Si volvemos a la ventana principal del PIC SIMULATOR IDE, y desde "Tools" -> "Microcontroller View" abrimos la vista del microntrolador, al darle "Start" a la simulación tendremos algo parecido a lo que sigue:


Imagen:PSIBASIC43.jpg

El pin 6, correspondiente a RB0 esta en "OFF" por que el pulsador del pin 17 (RA0) esta en OFF. Si con el mouse hacemos un click sobre la "T" que esta al lado del pin 17, la vista del microcontrolador pasara al estado que muestra la imagen siguiente:


Imagen:PSIBASIC44.jpg

Recordemos que el botón "T" significa "cambio" (Toggle) por lo que el estado del pin 17 permanecerá en alto hasta que lo pulsemos otra vez, y el estado del microcontrolador volverá a ser el inicial. Como en cualquier curso, conviene realizar estas practicas, que aunque puedan parecer muy sencillas nos ayudaran a conocer las herramientas disponibles y "tomar confianza" al programa. También es interesante el realizar cambios en el programa BASIC, recompilar y analizar los resultados.



IF - THEN - ELSE - ENDIF

En cualquier programa medianamente complejo que queramos realizar, seguramente necesitaremos en algún punto tomar alguna decisión basándonos en el estado de una entrada o en el valor de una variable. PIC BASIC incorpora instrucciones que nos permiten este tipo de comportamiento, siendo la mas sencilla y frecuentemente utilizada la sentencia IF - THEN - ELSE - ENDIF.

Existen varias formas de utilizar esta instrucción. Comenzaremos con los casos mas sencillos y a lo largo de este capitulo iremos agregando complejidad hasta ver todas las posibilidades.

CASO 1

El caso mas simple es el siguiente:

 IF condición THEN instrucción
 
"IF" significa "SI....", y "THEN" significa "LUEGO" o "ENTONCES". El caso anterior puede leerse como "SI se cumple la condición, entonces ejecuto la instrucción"

La "condición" es una expresión lógica que puede ser verdadera o falsa. En caso de ser verdadera, la instrucción a continuación del THEN será ejecutada. En caso de la condición sea falsa, el programa seguirá su ejecución con la instrucción siguiente al "IF - THEN".

Veamos un ejemplo. Supongamos el siguiente programa:

 ALLDIGITAL 'Voy a usar todos los pines como E/S.
 TRISA = %11111111 'Todo el PORTA como entradas
 DIM A AS BYTE 'Declaro la variable "A" como BYTE
 DIM TOTAL AS BYTE 'Declaro la variable "TOTAL" como BYTE
 '
 TOTAL = 10 'Le asigno el valor 10 a la variable "TOTAL"
 A = 2 'Le asigno el valor 2 a la variable "A"
 '
 IF PORTA.4 = 1 THEN A = 4
 '
 TOTAL = TOTAL + A 'Sumo a "TOTAL" el valor de "A"
 
Cundo comienza el programa, se declaran dos variables tipo BYTE (que pueden almacenar valores entre 0 y 255), y a TOTAL se le asigna el valor "0" y a "A" el valor "2". Hasta aquí, no hay nada que no hayamos visto antes.

La línea siguiente realiza la siguiente tarea: evalúa si la condición PORTA.4 = 1 es cierta. En caso de que efectivamente el valor presente en el bit 4 del PORTA sea "1", se ejecuta la instrucción a continuación del THEN, la variable "A" toma el valor "4", y se pasa a la instrucción de abajo. Si PORTA es igual a "0", se pasa a la instrucción siguiente sin mas.

El valor final de la variable "TOTAL" depende entonces de cual sea el estado de PORTA.4 al momento de hacer la evaluación. Si es igual a "1", "TOTAL" tendrá un valor de 14 (10 + 4). Si PORTA.4 = 0, "TOTAL" tendrá un valor de 12 (10 + 2).

Veamos algunos ejemplos validos de este caso:

 IF A = B THEN PORTA.0 = 1
 
 IF B > A THEN A = B
 IF B = 5 THEN A = 0
 IF (A = 0) OR (B = 5) THEN C = 2
 IF PORTA.0 THEN PORTB.3 = 0
 
En el ultimo ejemplo la condición PORTA.0 equivale a PORTA.0 = 1.



CASO 2

Muchas veces, luego de evaluar la condición necesitamos ejecutar mas de una instrucción. En los ejemplos vistos en el CASO 1 siempre se ejecutaba una sola instrucción cuando la condición era cierta. La manera de ejecutar múltiples sentencias dentro de una estructura IF-THEN implica emplear el ENDIF:

 IF condición THEN
   instrucción 1
   instrucción 2
   ...
   instrucción n
 ENDIF
 
No varia prácticamente nada respecto del primer caso, solo que esta vez se van a ejecutar todas las instrucciones que se encuentren entre el THEN y el ENDIF cada vez que condición sea verdadera.
Veamos un ejemplo. Supongamos el siguiente programa:

 DIM A AS BYTE 'Declaro la variable "A" como BYTE
 DIM B AS BYTE 'Declaro la variable "B" como BYTE
 DIM C AS BYTE 'Declaro la variable "C" como BYTE
 DIM D AS BYTE 'Declaro la variable "D" como BYTE
 DIM TOTAL AS BYTE 'Declaro la variable "TOTAL" como BYTE
 '
 TOTAL = 0 'Le asigno el valor 0 a la variable "TOTAL"
 A = 2 'Le asigno el valor 2 a la variable "A"
 B = 5 'Le asigno el valor 5 a la variable "B"
 C = 1 'Le asigno el valor 1 a la variable "C"
 D = 0 'Le asigno el valor 0 a la variable "D"
 '
 IF A = 2 THEN
   A = B + (C * D)
   TOTAL = A * B
 ENDIF
 
El ejemplo anterior, la condición A = 2 es verdadera (puesto que ese es el valor que le asignamos a "A" mas arriba), por lo que las dos instrucciones dentro del THEN-ENDIF se ejecutaran. Esto hace que TOTAL tome el valor de 10 (hagan las cuentitas!). Si "A" hubiese tenido otro valor, esas dos sentencias no se ejecutarían y TOTAL seguiría valiendo "0" al terminar el programa.



CASO 3

Hay veces que de acuerdo a la condición, queremos ejecutar un grupo u otro de instrucciones. Para eso, utilizamos el ELSE:

 IF condición THEN
   instrucciónv 1
   instrucciónv 2
   ...
   instrucciónv n
 ELSE
   instrucciónf 1
   instrucciónf 2
   ...
   instrucciónf n
 ENDIF
 
Es decir, si la condición es verdadera, se ejecutan las sentencias entre THEN y ELSE. Y si la condición es falsa, las que estén entre ELSE y ENDIF. "ELSE" puede ser traducido como "en otro caso" o "si no...".
Veamos un ejemplo. Supongamos el siguiente programa:

 ALLDIGITAL 'Voy a usar todos los pines como E/S.
 '
 TRISA = %11111111 'Todo el PORTA como entradas
 DIM A AS BYTE 'Declaro la variable "A" como BYTE
 DIM TOTAL AS BYTE 'Declaro la variable "TOTAL" como BYTE
 '
 TOTAL = 10 'Le asigno el valor 10 a la variable "TOTAL"
 A = 2 'Le asigno el valor 2 a la variable "A"
 '
 IF PORTA.4 = 1 THEN
   A = 4
   TOTAL = TOTAL + 5
 ELSE
   A = 0
   TOTAL = TOTAL + 15
 ENDIF
 
El ejemplo anterior, la condición PORTA.4 = 1 determina que bloque de instrucciones se ejecutan. Si es verdadera, A = 4 y TOTAL = TOTAL + 5 son usadas. Caso contrario se ejecutan A = 0 y TOTAL = TOTAL + 15. Luego, independientemente de cual haya sido el caso, el programa sigue con la sentencia que se encuentre a continuación del ENDIF.

Por ultimo, tenemos que saber que es posible "anidar" instrucciones IF-THEN-ELSE-ENDIF, con lo que se pueden tomar decisiones verdaderamente complejas. Por supuesto, tenemos que ser cautos en el uso de esta característica ya que debido a limitaciones en el tamaño de la pila y cantidad de memoria disponible del PIC podemos ocasionar un desborde y el programa colapsara. Este seria un ejemplo de un anidamiento:
 
 IF PORTB.1 = 1 THEN
     IF A = 2 THEN
       A = B + (C * D)
       TOTAL = A * B
   ELSE
       A = 0
   ENDIF
 ELSE
   A = 19
 ENDIF
 
Las sentencias en color negro corresponden a una estructura IF-THEN-ELSE-ENDIF y las que están en verde a la otra, que se encuentra dentro ("anidada" en) de la primera.

FOR - TO - STEP - NEXT

Así como la toma de decisiones que vimos en el capitulo anterior esta presente en casi todos nuestros programas, las estructuras que permiten repetir un grupo de instrucciones un numero determinado de veces también son indispensables. En PIC SIMULATOR IDE hay dos de ellas. Veremos en este capitulo la primera, FOR - TO - STEP - NEXT.

Esta estructura necesita una variable (tipo Byte o Word) para funcionar. En cada iteración del bucle, la variable va cambiando su valor. Cuando el valor de la variable alcanza o supera el valor prefijado, el bucle termina. La forma del bucle es la siguiente:

 FOR variable = valor_inicial TO valor_final STEP paso
  instruccion1
  instruccion2
  ...
  instruccionn
 NEXT variable
 
Veamos un ejemplo concreto. Supongamos que queremos sumar los números del 1 al 100. El programa quedaría como sigue:

 DIM A AS BYTE           'Declaro la variable "A" como BYTE
 DIM TOTAL AS WORD       'Declaro la variable "TOTAL" como WORD
 '
 TOTAL = 0               'Asigno "0" a la variable "TOTAL".
 '
 FOR A = 1 TO 100 STEP 1 '"A" va de 1 a 100 de 1 en 1
  TOTAL = TOTAL + A    'Sumo "A" al valor de "TOTAL".
 NEXT A                  'fin del bucle.
 
Hemos declarado la variable A como BYTE, ya que su valor va a mantenerse en el rango 0..255. Para TOTAL utilizamos una variable tipo WORD, ya que la suma va a superar el valor máximo de un BYTE. (Recordemos que WORD permite valores en el rango 0..65535)

El bucle se ejecuta 100 veces, la primera de ellas A vale 1, la segunda 2, la tercera 3, hasta la ultima en la que vale 100. Ese incremento (1 por ves) esta dado por el valor a continuación del STEP. En los casos como este en que STEP vale 1, puede omitirse, como veremos en ejemplos posteriores.

TOTAL comienza valiendo 0 (se le asigna ese valor fuera del bucle) y en cada iteración se le suma el valor que tenga A en ese momento. De esa manera, TOTAL va tomando los valores 1, 3, 6, 10, .... 5050.
Tanto valor_inicial como valor_final y paso pueden ser variables. El siguiente trozo de código hace lo mismo que el anterior, pero usa variables:

 DIM A AS BYTE           'Declaro la variable "A" como BYTE
 DIM INICIO AS BYTE      'Declaro la variable "INICIO" como BYTE
 DIM FINAL AS BYTE       'Declaro la variable "FINAL" como BYTE
 DIM PASO AS BYTE        'Declaro la variable "PASO" como BYTE
 DIM TOTAL AS WORD       'Declaro la variable "TOTAL" como WORD
 '
 INICIO = 1              'Asigno "1" a la variable "INICIO".
 FINAL = 100             'Asigno "100" a la variable "FINAL".
 PASO = 1                'Asigno "1" a la variable "PASO".
 TOTAL = 0               'Asigno "0" a la variable "TOTAL".
 '
 FOR A = INICIO TO FINAL STEP PASO '"A" va de 1 a 100 de 1 en 1
    TOTAL = TOTAL + A    'Sumo "A" al valor de "TOTAL".
 NEXT A                  'fin del bucle.
 
Y el mismo ejemplo, sin usar STEP:

 DIM A AS BYTE           'Declaro la variable "A" como BYTE
 DIM TOTAL AS WORD       'Declaro la variable "TOTAL" como WORD
 '
 TOTAL = 0               'Asigno "0" a la variable "TOTAL".
 '
 FOR A = 1 TO 100        '"A" va de 1 a 100 de 1 en 1
  TOTAL = TOTAL + A    'Sumo "A" al valor de "TOTAL".
 NEXT A                  'fin del bucle.

Hay casos en que es necesario que el valor de la variable de control del bucle se decremente en lugar de ir aumentando. En ese caso, se puede usar un valor negativo para STEP. El siguiente ejemplo cuenta desde 50 hasta 20, de 5 en 5:

 DIM A AS BYTE           'Declaro la variable "A" como BYTE
 '
 FOR A = 50 TO 20 STEP -5 '"A" va de 50 a 20 de 5 en 5
  instruccion1
  instruccion2
  ...
  instruccionn
 NEXT A                  'fin del bucle.

De la misma manera que ocurría con IF-THEN-ELSE-ENDIF, pueden anidarse diferentes bucles FOR-TO-STEP-NEXT , uno dentro de otro:

 FOR variable1 = valor_inicial1 TO valor_final1 STEP paso1
  FOR variable2 = valor_inicial2 TO valor_final2 STEP paso2
     instruccion1
     instruccion2
     ...
     instruccionn
  NEXT variable2
 NEXT variable1
 
La única condición es que un bucle este completamente dentro del otro. El siguiente anidamiento daría un error en el compilador:

 FOR variable1 = valor_inicial1 TO valor_final1 STEP paso1
  FOR variable2 = valor_inicial2 TO valor_final2 STEP paso2
     instruccion1
     instruccion2
     ...
     instruccionn
  NEXT variable1
 NEXT variable2
 
Para terminar, veamos el siguiente código:

 AllDigital
 TRISB = 0
 Dim a As Byte
 For a = 0 To 15
  PORTB = a
 Next a
 
Si se lo corre en el PIC SIMULATOR IDE, puede verse como los primeros 4 bits del PORTB cuentan en binario de 0 a 15.



WHILE - WEND

La segunda estructura de control que proporciona PIC BASIC es WHILE - WEND. Su propósito es el mismo que la que vimos en el capitulo anterior, y su estructura es la siguiente:

 WHILE condición 
  instruccion1
  instruccion2
  ...
  instruccionn
 WEND
 
Mientras que la condición sea verdadera, el grupo de instrucciones dentro del cuerpo del WHILE-WEND se ejecuta. Las características de la condición son las mismas que vimos en el capitulo 10 para IF-THEN-ELSE-ENDIF.

Por supuesto, si no somos cuidadosos al momento de elegir la condición, puede darse el caso de que el numero de repeticiones del bucle sea infinito, y nunca salgamos de el. De hecho, esta circunstancia se aprovecha en algunos programas para repetir indefinidamente un grupo de instrucciones. También hay que tener presente que si la condición no es cierta al momento de ejecutar la primera vez el WHILE, el flujo del programa pasara directamente a la instrucción posterior al WEND y las instrucciones dentro del bucle no se ejecutaran ninguna vez.

No hay mucho mas para decir de WHILE-WEND , solo analizar algunos ejemplos:
Ejemplo 1: El siguiente es un bucle infinito. Como dentro del cuerpo del WHILE-WEND no se cambia el valor de la variable A, esta siempre vale "0" y la condición del WHILE nunca es falsa, por lo que se repite eternamente:

 DIM A AS BYTE
 A = 0
 ...
 WHILE A = 0
   instruccion1
   instruccion2
   ...
   instruccionn
 WEND
 ...
 
Ejemplo 2: Las instrucciones dentro del siguiente WHILE-WEND no se ejecutan nunca, dado que la condicion siempre es falsa:

 DIM A AS BYTE
 A = 0
 ...
 WHILE A > 0
   instruccion1
   instruccion2
   ...
   instruccionn
 WEND
 ...
 
Ejemplo 3: Las instrucciones dentro del siguiente WHILE-WEND se ejecutan 10 veces, y al terminar la variable B contiene la suma de los números del 0 al 10 naturales:

 DIM A AS BYTE
 DIM A AS BYTE 
 A = 0
 B = 0
 '
 WHILE A < 10
    A = A + 1 'Incremento la variable A
    B = B + A 'Sumo a B el valor de la variable A
 WEND
 
Cuando A = 10, se suma su valor a A, y al llegar al WEND el control del programa se transfiere al WHILE, donde se evalúa la condición A < 10, se determina que es falsa, y el programa pasa el control a la línea que exista después del WEND.

LOOKUP

La función LOOKUP puede ser utilizada para seleccionar un Byte desde una lista de constantes del mismo tipo, de acuerdo al valor de un índice (también de tipo Byte). El resultado de la selección se almacena (como no!) también en una variable tipo byte.

La forma de la función LOOKUP es la siguiente:

 variable = LOOKUP(byte0, byte1, ..., byteN), indice
 
Veamos un ejemplo sencillo:

 DIM indice AS BYTE
 DIM variable AS BYTE
 indice = 3
 variable = LOOKUP(25, 35, 55, 70, 85, 100), indice
 ...
 
variable tendrá el valor "70" (decimal) al ejecutar este código. El primer elemento de la lista, recordemos, corresponde al valor "0" de indice.

Si bien la lista puede contener un máximo de 255 elementos, que es el máximo direccionable por una variable indice de tipo byte, hay que asegurarse que el microcontrolador que estamos empleando tenga memoria suficiente para albergarla.

El segundo ejemplo, extraído de la propia ayuda del PIC SIMULATOR IDE, nos muestra como manejar un display LED de siete segmentos conectado al puerto B:


 Dim digito As Byte
 Dim mascara As Byte
 'Comienzo el bucle principal
 loop:
     TRISB = 000000
     For digito = 0 To 9
         mascara = LookUp(0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f), digito
         PORTB = mascara
         WaitUs 10 'esta demora debe ser mayor si no es una simulación!
     Next digito
 Goto loop
 
Este es el aspecto que muestra el simulador cuando ejecutamos el programa anterior. Debemos asegurarnos de que uno de los dígitos LED este configurado como conectado al puerto PORTB, tal como se ve en la imagen:


Imagen:PSIBASIC45.jpg

Si algunas o todas las constantes de la lista son valores ASCII, se puede hacer mas corta y legible la misma utilizando como parte de ella una cadena de caracteres, como se ve a continuación.

 MASK = LOOKUP("ABCDEFGHIJK"), INDEX
 
"A" seria el valor que tendría MASK cuando INDEX vale "0", y "K" cuando INDEX tenga el valor "10".
Por ultimo, en caso de que el valor de INDEX sea mayor a la cantidad de argumentos de la lista, el valor de la variable (en este ejemplo MASK) no cambia.

SHIFTLEFT y SHIFTRIGHT

SHIFTLEFT y SHIFTRIGHT son funciones a nivel bit que pueden ser utilizadas para "correr" el contenido de variable a la izquierda o a la derecha. Cada uno de los bits que componen la variable se desplazan una posición (a la izquierda o a la derecha, de acuerdo a que función utilicemos). Esto tiene dos consecuencias. En primer lugar, el bit de mas a la izquierda (SHIFTLEFT) o derecha (SHIFTRIGHT) se pierde. Y el espacio creado en el otro extremo se completa con un "0".
Imagen:PSIBASIC46.jpg
SHIFTLEFT


Imagen:PSIBASIC47.jpg
SHIFTRIGHT

El siguiente ejemplo muestra como utilizar estas funciones en un programa:

 TRISB = 0x00
 PORTB = 000011
 goleft:
   WaitUs 5 'esta demora debe ser mayor si no es una simulación!
   PORTB = ShiftLeft(PORTB, 1)
   If PORTB = %11000000 Then Goto goright
   Goto goleft
 goright:
   WaitUs 5 'esta demora debe ser mayor si no es una simulación!
   PORTB = ShiftRight(PORTB, 1)
   If PORTB = 000011 Then Goto goleft
   Goto goright
 
Lo que hace el programa es muy sencillo: enciende los dos primeros bits del PORTB, espera un tiempo, los desplaza hacia la izquierda, si esos bits llegaron al extremo de la variable tipo byte que es el PORTB, se invierte el sentido del desplazamiento.

Displays LCD

LCD alfanuméricos

A grandes rasgos, y a pesar de la simplicidad que brinda el disponer de un mismo integrado especializado en casi todos los modelos de displays, la escritura en estos es relativamente compleja, dado que se deben respetar protocolos de inicialización, tiempos entre envío de datos, etc., lo que hace bastante tediosa su programación en assembler.

Pero PIC BASIC dispone de un juego de instrucciones especiales para manejar displays en modo “8 bits” y en modo “4 bits” que nos evitan toda esa complejidad.

El manejo de los LCD se hace mediante el uso de sentencias “DEFINE”, que le dicen al compilador a que pines del microcontrolador hemos conectado cada uno de los pines del LCD. La forma de la instrucción DEFINE es la siguiente:

 DEFINE parametro = valor
 
Donde “parametro” es el nombre del parámetro al que le queremos asignar el “valor”. Los parámetros disponibles para el manejo de LCD alfanuméricos son los siguientes:
  • LCD_BITS: Define el número de bits de la interfaz de datos. Se pueden asignar valores de 4 u 8, siendo 4 el valor por defecto.
  • LCD_DREG: Define a que puerto del PIC tenemos conectado el port de datos del LCD. Los valores permitidos son PORTA, PORTB, PORTC, etc. Por defecto se asume PORTB.
  • LCD_DBIT: Define cual es el primer pin del puerto que usamos para enviar los datos al LCD cuando seleccionamos un bus de 4 bits. Solo puede ser el 0 (para los pines el 0, 1, 2 y 3) o 4 (para usar los pines 4, 5, 6 y 7). Por defecto se asume “4”, y esta instrucción se ignora para LCD_BITS = 8.
  • LCD_RSREG: Define a que puerto del PIC tenemos conectado el pin RS del LCD. Los valores permitidos son PORTA, PORTB, PORTC, etc. Por defecto se asume PORTB.
  • LCD_RSBIT: Define a que pin del puerto tenemos conectado el pin RS del LCD. Por defecto se asume “3”.
  • LCD_EREG: Define a que puerto del PIC tenemos conectado el pin E del LCD. Los valores permitidos son PORTA, PORTB, PORTC, etc. Por defecto se asume PORTB.
  • LCD_EBIT: Define a que pin del puerto tenemos conectado el pin E del LCD. Por defecto se asume “2”.
  • LCD_RWREG: Define a que puerto del PIC tenemos conectado el pin RW del LCD. Los valores permitidos son 0, PORTA, PORTB, PORTC, etc. Por defecto se asume “0”, que significa “no usamos el pin RW”.
  • LCD_RWBIT: Define a que pin del puerto tenemos conectado el pin RW del LCD. Por defecto se asume “0”, que significa “no usamos el pin RW”.
  • LCD_COMMANDUS: Define cuantos microsegundos demora la escritura de un comando en el display. Por defecto, este valor es de 5000. La mayoría de los LCD funcionan bien con un valor de 2000, lo que hace más rápidos nuestros programas.
  • LCD_DATAUS: Define cuantos microsegundos demora la escritura de un dato en el LCD. Por defecto, este valor es de 100.
  • LCD_INITMS: Define cuantos microsegundos demora la inicialización e la electrónica del LCD. Por defecto, este valor es de 100.
Luego, tenemos una serie de instrucciones que manejan el envío de comandos e instrucciones al display:
LCDINIT debe utilizarse antes de enviar cualquier comando o dato al LCD. La forma de esta instrucción es al siguiente:


 LCDINIT n

Donde “n” es el tipo de cursor que queremos que muestre el display. “0” significa que el cursor estará oculto, “1” significa que el cursor parpadeara, “2” nos mostrara un cursor subrayado, y “3” un cursor subrayado y parpadeando.
LCDCMDOUT es la instrucción que envía comandos al LCD. Se emplea de la siguiente manera:


 LCDCMDOUT comando

Donde “comando” es alguno de los siguientes:


  • LcdClear: Borra el contenido del LCD.
  • LcdHome: Lleva el cursor a la primera posición del primer renglón del LCD.
  • LcdLine2Home: Lleva el cursor a la primera posición del segundo renglón del LCD.
  • LcdLeft: Mueve el cursor una posición a la izquierda.
  • LcdRight: Mueve el cursor una posición a la derecha.
  • LcdShiftLeft: Desplaza el contenido del LCD una posición a la izquierda.
  • LcdShiftRight: Desplaza el contenido del LCD una posición a la derecha.
  • LcdLine1Clear: Borra la primera línea del LCD.
  • LcdLine2Clear: Borra la segunda línea del LCD.
  • LcdLine1Pos(x): Coloca el cursor en la posición “x” del primer renglón del LCD. “X” puede tener cualquier valor entre 1 y 40
  • LcdLine2Pos(x): Coloca el cursor en la posición “x” del segundo renglón del LCD. “X” puede tener cualquier valor entre 1 y 40

LCDOUT envía datos al display. Si son caracteres, simplemente los ponemos entre comillas a continuación del comando. Si se trata de mostrar el contenido de una variable, se escribe la variable (precedida por “#”) a continuación del comando. Si se necesitan imprimir varias variables, se pueden separar por “comas”.
A continuación, un par de ejemplos de cómo se utilizan todas estas instrucciones. El primero se encarga de mostrar un texto parpadeando en la primera línea del display. Intenten deducir como está conectado el LCD al PIC mirando las instrucciones “DEFINE” del principio del programa.


 DEFINE LCD_BITS = 8
 DEFINE LCD_DREG = PORTB
 DEFINE LCD_DBIT = 0
 DEFINE LCD_RSREG = PORTD
 DEFINE LCD_RSBIT = 1
 DEFINE LCD_EREG = PORTD
 DEFINE LCD_EBIT = 3
 DEFINE LCD_RWREG = PORTD
 DEFINE LCD_RWBIT = 2
 '
 LCDINIT 0 ‘inicializo el LCD sin cursor.
 '
 loop:
   LCDOUT "www.uControl.com" ‘Muestra el texto…
   WAITMS 1000 ‘Espero un segundo
   LCDCMDOUT LcdClear ‘Borro el display
   WAITMS 1000 ‘Espero un segundo
 GOTO loop ‘Vuelvo a loop: para repetir indefinidamente.

El segundo ejemplo muestra como imprimir el contenido de una variable (“A”) en el LCD. Concretamente, se muestra un texto en el primer renglón, mientras que en el segundo se cuentan los números del 65535 al 0 en el segundo.


 DEFINE LCD_BITS = 8
 DEFINE LCD_DREG = PORTB
 DEFINE LCD_DBIT = 0
 DEFINE LCD_RSREG = PORTD
 DEFINE LCD_RSBIT = 1
 DEFINE LCD_EREG = PORTD
 DEFINE LCD_EBIT = 3
 DEFINE LCD_RWREG = PORTD
 DEFINE LCD_RWBIT = 2
 '
 DIM A AS WORD
 A = 65535
 '
 LCDINIT 3 ‘Cursor parpadeando
 WAITMS 1000
 '
 loop:
   LCDOUT "¡Estoy contando!” ‘Texto del primer renglón
   LCDCMDOUT LcdLine2Home ‘Paso al Segundo renglón
   LCDOUT #A ‘Muestro el valor de A
   A = A - 1
   WAITMS 250
   LCDCMDOUT LcdClear ‘Limpio del display
 GOTO loop