Uso del MikroBasic para la

programación de
Microcontroladores PIC

Ing. Marco Dujmovic

 MikroBasic
MikroBasic es una herramienta creada
por MikroElektronika, y diseñada para
programar microcontroladores PIC de
Microchip con lenguaje Basic.

Basic es un lenguaje de alto nivel, el

cual permite programar de forma
estructurada, simple y de forma
intuitiva. Es un lenguaje tan antiguo
como lenguaje C, pero menos
riguroso. Permite el uso de funciones y
procedimientos, pero también el uso
de saltos a subrutinas.
 Esquema básico del programa
program <program name> ' procedures declarations
include <include other modules> sub procedure procedure_name(...)
  <local declarations>
'***************************************** ...
************ end sub
'* Declarations (globals):  
'***************************************** ' functions declarations
************* sub function function_name(...) as return_type
<local declarations>
' symbols declarations ...
symbol ... end sub
   
' constants declarations '*****************************************
const ... *
  '* Program body:
' structures declarations '*****************************************
structure ... *

' variables declarations main:

dim Name[, Name2...] as [^]type [absolute 0x123] ' write your code here
[external] [volatile] [register] [sfr] end.
 Variables
Cada variable declarada consume una parte de la memoria
RAM del PIC. El tipo de dato de la variable no solo
delimita el rango de la variable sino también determina el
espacio usado en la memoria RAM del PIC.

Tenga en mente que realizar operaciones con diferentes

tipos de variables toma diferentes tiempos en ser
completadas. MikroBasic recicla el espacio de variables
locales declaradas en diferentes rutinas y procedimientos
comparten el mismo espacio de memoria si es posible.
 Variables
La forma de declarar las variables es la siguiente:
dim i, j, k as byte
dim counter, temp as word
dim samples as longint[100]
Predefiniendo globales y constantes
Para facilitar la programación, MikroBasic implementa un número predefinido
de Variables globales y constantes.

Todos los Registros SFR del PIC están declarados implícitamente como
variables globales del tipo
byte, y son visibles en todo el proyecto.

Cuando se crea un proyecto, Mikrobasic incluirá el archivo apropiado con

extensión .def, el cual contiene las declaraciones disponibles del SFR y
constantes
(como PORTB, TMR1, etc.).

Los identificadores están todos en mayúsculas, idénticos a las

nomenclaturas de las hojas de datos de MICROCHIP.
 Constantes
Una constante es un dato cuyo valor no puede ser cambiado durante el tiempo
de ejecución.

Usar una constante en un programa no consume memoria RAM de un PIC.

Una constante puede usarse en cualquier expresión pero no se le puede asignar

otro valor.

Las constantes son declaradas en la sección de declaración de un programa.

Cada constante es declarada bajo un único nombre, el cual debe ser un

identificador valido. Es una tradición escribir las constantes en mayúsculas. Una
constante necesita que se especifique su valor (value) que es una literal
apropiada para el tipo de dato usado.
 Constantes
La forma de declarar las constantes es la siguiente:
const constant_name [as type] = value

Ejemplos:
const MAX as longint = 10000
const MIN = 1000 ' compiler will assume word type
const SWITCH = "n" ' compiler will assume char type
const MSG = "Hello" ' compiler will assume string type
const MONTHS as byte[12] = (31,28,31,30,31,30,31,31,30,31,30,31)
 Etiquetas
Las etiquetas sirven como objetivos para las declaraciones goto y gosub.

La forma de declarar las etiquetas es la siguiente:

label_identifier : statement

No se necesitan declaraciones especiales para las etiquetas en mikroBasic. El nombre de la

etiqueta necesita ser un nombre de identificador valido, las declaraciones etiquetadas y las
declaraciones goto, gosub deben estar en el mismo bloque. No es posible saltar hacia una
función o un procedimiento, No establezca una misma etiqueta para dos identificadores
diferentes.

Ejemplo de uso:
loop:
Beep
goto loop
 Arreglos
Un arreglo representa una colección de elementos indexados del mismo tipo
(llamados tipo de base). Como cada elemento contiene su propio índice, los
arreglos pueden contener significativamente más de una vez el mismo valor.

Cada elemento del arreglo es numerado desde 0 hasta la longitud del arreglo.
Cada elemento del arreglo es de un tipo y puede ser accedido especificando su
nombre seguido del numero de índice dentro de corchetes.

La forma de declarar los arreglos es la siguiente:

dim weekdays as byte[7]
dim samples as word[50]

if samples[37] = 0 then
...
 Símbolos
En Basic los símbolos permiten crear macros sin necesidad de parámetros. Puede reemplazar cualquier línea de código por un
identificador alias. Cuando los símbolos son usados correctamente pueden incrementar la usabilidad y la legibilidad del código.

Los símbolos necesitan ser declarados inmediatamente después del inicio del modulo, justo después del nombre del modulo y
opcionalmente de las cláusulas incluye. Vea organización de programa para mas detalles. El alcance de un símbolo esta siempre limitado
al archivo en el cual fue declarado. La forma de declararlas es:

symbol alias = code

Ejemplo:

symbol MAXALLOWED = 216 ' Símbolo como alias para un valor numérico
Symbol SALIDA = PORTA ' Símbolo como alias para un puerto
symbol MYDELAY = Delay_ms(1000) ' Símbolo como alias para un llamado a procedimiento

dim cnt as byte ' una variable

'...
main:
if cnt > MAXALLOWED then
cnt = 0
SALIDA.1 = 0
MYDELAY
end if
Declaraciones de asignación
Las declaraciones de asignación tiene la siguiente forma:

variable = expresión

La declaración evalúa la expresión y le asigna el valor a la

variable. Todas las reglas de la conversión implícita se aplican.
Variable puede ser declarada como una variable o como un
arreglo y expresión puede ser cualquier expresión.

No confunda la asignación con el operador relacional igual (=),

que prueba una igualdad. Mikrobasic interpretará el signo igual
(=) dentro de su contexto.
 Declaración IF
Use declaraciones IF para implementar una declaración condicional. La
sintaxis de las declaraciones IF es la siguiente:
IF expresión THEN
declaraciones
ELSE
Otras declaraciones
END IF

Donde la expresión es evaluada, si es verdadero las declaraciones se

ejecutan. Si la expresión es falsa se ejecutaran otras declaraciones. La
expresión debe ser convertida a tipo bolean, de otra forma la expresión
está mal formulada. La palabra reservada else y las otras declaraciones
son opcionales.
Declaración SELECT CASE
Use la declaración select case para pasar el control o saltar a una rutina de
programa, basado en una condición certera. La palabra clave select case
consiste en un selector de una expresión ( una condición) y una lista de posibles
valores. La sintaxis de select case es la siguiente:

select case selector

case valor_1
declaraciones_1
...
case valor_n
declaraciones_n
case else
Declaraciones _default]
end select
 Declaracion FOR
La declaración de un FOR determina un ciclo de iteración y requiere que se especifique el número de
iteraciones. La sintaxis de una sentencia FOR es:

for contador = valor inicial to valor final [step valor de paso]

declaraciones
next contador

El contador es una variable que se incrementa según el valor del paso con cada iteración del ciclo. El
parámetro valor de paso es un valor entero opcional y si este es omitido el valor por defecto es 1, antes de la
primera iteración, el valor del contador es puesto al valor inicial y se incrementa mientras no exceda o no
llegue al valor final, con cada iteración las declaraciones son ejecutadas. Los valores iniciales y finales deben
ser valores compatibles con el contador; las declaraciones pueden ser cualquier tipo de declaraciones siempre
y cuando no afecten el valor del contador. Note que el valor de paso puede ser un valor negativo,
permitiéndole hacer cuentas regresivas. Aquí un ejemplo de cómo calcular el producto escalar de 2 vectores a
y b, de longitud n usando la sentencia FOR:
 Declaración WHILE
Use la sentencia WHILE para condicionar una declaración de iteración. La sintaxis
es:
while expresión
declaraciones
wend

Las declaraciones se ejecutaran repetidamente, mientras la expresión sea

verdadera, esto es si la expresión al ser evaluada la primera vez es falsa no se
ejecutaran las declaraciones. Aquí esta un ejemplo de cómo calcular el producto
escalar de 2 vectores usando la sentencia WHILE:
 Declaración DO
La sentencia do ejecuta un ciclo mientras la condición sea verdadera. La sintaxis es:

do
declaraciones
loop until expresión

Las declaraciones son ejecutadas mientras la expresión evaluada sea verdadera. La

expresión es evaluada después de cada iteración. Entonces las todas declaraciones
se ejecutarán.

Aquí hay un ejemplo de cómo calcular el producto escalar de 2 vectores, usando la

sentencia DO:
Accediendo a los bits individuales
Mikrobasic permite acceder de forma individual a cada Bit de una variable. Simplemente use un
punto (.) con la variable, seguido de un numero.
Por Ejemplo:

if PORTB.0 = 1 then
variable = 14
endif

No hay necesidad por una declaración en especial; este tipo de acceso selectivo es una
característica intrínseca de mikrobasic y puede ser usada en cualquier parte del código. Asegúrese
de no exceder el tamaño del tipo apropiado.(P.E. PORTB.12 retornara un error ya que el PORTB
es una variable de 8 bits).

Si esta familiarizado con un Chip en particular, puede acceder a sus bits por su nombre:

' Limpiar TMR0F

INTCON.TMR0F = 0
Funciones y Procedimientos
Las funciones y los procedimientos, colectivamente se
refieren a las rutinas, son subprogramas
(autocontenidos en bloques de declaraciones) los
cuales realizan una tarea especifica de acuerdo al
número de entradas y parámetros. Una función regresa
un parámetro cuando esta es finalizada,
un procedimiento no lo hace.
 Funciones
Ejemplo:

Aquí hay un ejemplo de una función que calcula el numero x↑ n basado en dos parámetros de entrada: x y n donde
n tiene que ser mayor que cero (n>0):

sub function power(dim x, n as byte) as longint

dim i as byte
i=0
result = 1
if n > 0 then
for i = 1 to n
result = result*x
next i
end if
end sub

Ahora aquí se realiza la llamda de la funcion para calcular el numero 312 :

tmp = power(3, 12)

 Procedimientos
Ejemplo:

Aquí hay un ejemplo donde se utiliza un

procedimiento el cual prepara las entradas de tiempo
para ser visualizadas por un LCD.

sub procedure time_prep(dim byref sec, min, hr as byte)

sec = ((sec and $F0) >> 4)*10 + (sec and $0F)
min = ((min and $F0) >> 4)*10 + (min and $0F)
hr = ((hr and $F0) >> 4)*10 + (hr and $0F)
end sub
 Voltímetro con 16F877
Revisar el código suministrado y correr la simulación
de Proteus.
Voltímetro con 16F877