El Compilador Bascom AVR

Bascom AVR es el compilador Basic para los AVR que sobresale entre los de su clase, aunque, la verdad, no tiene mucha competencia. Soporta los AVR de 8 bits, desde los ATtiny hasta los Xmega. La sintaxis de sus funciones tiene ciertas diferencias respecto de otros compiladores Basic como MBasic o Proton Plus, pero en general es fácil de asimilar.

Bascom AVR ofrece aceptables librerías, incorpora un sencillo simulador, un terminal serial y un excelente software programador de AVRs que soporta casi todos dispositivos conocidos como el USB-ISP, PROGGY, FLIP, USBprog/AVR ISP mkII (AVRISP), KamProg for AVR,  STK600, ARDUINO, etc., etc.

Mark Alberts desarrolló Bascom AVR como una adaptación de su compilador Basic para los microcontroladores 8051. Actualmente lo mantiene desde su empresa MCS electronics y ofrece un versión demo que la puedes descargar desde de aquí. Es completamente funcional y solo tiene el limitante de generar códigos ejecutables de hasta 4 kbytes.

Uso de Bascom AVR

Como buen compilador Basic, Bascom AVR es fácil de usar desde su instalación. Cada vez que se ejecute el programa se presentará un mensaje con un tip del compilador. Puede ser muy útil para aprender a usarlo pero si te llega a cansar puedes desmarcar la casilla Show tips at startup. Si más adelante quisieras volver a ver estos consejos los podrás reactivar yendo al menú View > Tip.

El IDE de Bascom AVR es de lo más minimalista. Para crear programas no se necesita configurar proyectos y raras veces un programa se divide en varios archivos. Así que para compilar un programa existente simplemente abres el archivo .BAS y lo compilas. Puedes practicar haciendo esto con los programas de ejemplo que trae el compilador en su carpeta SAMPLES.

Ahora crearemos un programa desde cero, procedimiento que es casi lo mismo. Vamos al menú File > New y se nos creará automáticamente el archivo donde escribir el código.

El programa que escribiremos corresponde a una adaptación de la práctica con teclado disponible en control de teclado matricial. Su listado se muestra a continuación y puedes copiarlo todo y pegarlo en el editor de Bascom AVR.

'*****************************************************************************
'  FileName:   main.bas
'  Purpose:    Control de teclado matricial de 4x4
'  Processor:  ATmega164P
'  Compiler:   Bascom AVR
'  Author:     Shawn Johnson. http://www.cursomicros.com.
'
'  Copyright (C) 2008 - 2012 Shawn Johnson. All rights reserved.
'
'  License:    Se permiten el uso y la redistribución de este código con
'              modificaciones o sin ellas, siempre que se mantengan esta
'              licencia y la nota de autor de arriba.
'****************************************************************************

$regfile = "m164Pdef.dat"             ' Seleccionar el microcontrolador
$crystal = 8000000                    ' Seleccionar la frecuencia del XTAL
$baud = 9600                          ' Establecer baud rate del USART0
$hwstack = 32                         ' hardware stack
$swstack = 16                         ' SW stack
$framesize = 32                       ' Frame space

Declare Sub Keypad_released()

Config Kbd = Portb , Debounce = 100 , Delay = 10 , Cols = 4

Dim Tecla As Byte

Print " Control de Teclado Matricial de 4x4 "

Do

    Tecla = Getkbd()
    If Tecla <> 16 Then          ' Sí hubo Tecla pulsada (si es diferente de 16)
        Tecla = Lookup(tecla , Keys)  ' Obtener tecla pulsada
        Print Chr(tecla)
        Keypad_released            ' Esperar teclado libre
    End If

Loop

End

'****************************************************************************
' Espera hasta que el teclado quede libre.
'****************************************************************************
Sub Keypad_released()
Local C As Byte
Do
    C = Getkbd()               ' Escanear teclado
Loop Until C = 16              ' Mientras se detecte alguna tecla pulsada
End Sub

'****************************************************************************
Keys:
Data "789A456B123C.0#D"

Antes de compilar el nuevo programa debemos guardarlo. Bueno simplemente busca una carpeta y guarda lo único que se puede guardar ;) y  El nombre es irrelevante. Yo, como nativo del lenguaje C, tengo la costumbre de llamarle main.

Con el código debidamente escrito y guardado no queda otra cosa más que compilarlo. Puedes seleccionar el menú Program > Compile, presionar la tecla F7 o el botón . Si el programa se compila sin errores veremos brevemente la siguiente ventanita indicando la cantidad de memoria flash usada.

Pero si queremos un reporte más detallado del uso de las memorias podemos ir al menú Program > Show result o presionar el botón .

Simulación del Programa

Como siempre, el primer simulador a considerar es el ya venerable Proteus VSM y el hecho de que también soporte los programas creados con Bascom AVR solo confirma su bien ganada reputación.

Más que simular de corrido un programa, para lo que bastaría usar el archivo HEX, Proteus permite depurar el programa ejecutándolo paso a paso y para esto se debe trabajar con el archivo OBJ generado por Bascom AVR. Si no conoces como cargar este archivo en el AVR de Proteus, puedes revisar la sección Cargar el Programa del Microcontrolador, del capítulo dedicado a Proteus, donde además encontrarás toda la información necesaria para realizar simulaciones con microcontroladores. Allí se trabaja con programas en C pero los procedimientos son igualmente aplicables a los programas en Basic.

Quizá te desilusione un poco ver que por ahora el código solo se muestra en blanco y negro, como se ve en la siguiente captura. En las versiones antiguas de Proteus tampoco los programas en C se mostraban a colores.

Por otro lado, también podemos utilizar el simulador que viene integrado en el IDE de Bascom AVR. Este simulador tiene dos modos, uno que es una simulación casi real, es decir con el AVR en su circuito real recibiendo instrucciones desde el ordenador vía el USART. El AVR recibe las instrucciones, las interpreta y ejecuta al estilo de los Basic Stamp, y finalmente devuelve los resultados al ordenador para ser visualizados por el simulador de Bascom AVR. No deja de venirnos a la mente el recuerdo de los emuladores JTAGICE, ¿verdad?

El otro modo de simulación es puro software, y es a lo que nos avocaremos en esta ocasión. Bien, para iniciar la simulación seleccionamos el menú Compile > Simulate. En primer lugar nos recibirá una ventanita que nos informa que si están abiertos los paneles de los registros de E/S o de las Memorias del AVR, la simulación será más lenta porque se tendrán que procesar y visualizar esos datos.

Aceptamos la advertencia dando clic a OK y a continuación estaremos en el entorno de simulación, del que no voy a describir cada uno de sus elementos para no extender este tutorial y porque son fáciles de captar. Más bien haremos un uso práctico de algunos componentes que dejará en claro que el resto son iguales de manejar.

Empezamos por visualizar el panel de los dispositivos hardware externos como el LCD y el teclado matricial e 4x4. Esto se consigue presionando el botón .

Para reducir el espacio haz clic derecho en un área del panel y en el menú emergente escoge Hide LCD para esconder el LCD. Ojalá se pudieran ocultar lo otros dispositivos no utilizados.

El panel Locals puede mostrar algunas variables pero solo si son de ámbito local, es decir si pertenecen a funciones o subrutinas. En este programa sería la variable C de la subrutina Keypad_released. Las otras variables como Tecla (que es la principal en este programa) las tenemos que colocar manualmente. Esto se hace en el panel Variables. Allí enfocamos un casillero cualquiera y escogemos el ítem deseado, en nuestro caso, tecla, como se aprecia e la siguiente figura. Del mismo modo puedes colocar otros datos.

Arriba, a la izquierda, tenemos los botones de comandos de la simulación. Están Run (correr), Pausa, Stop, y los clásicos Step Over, Step into y Run to cursor presentes en todos los simuladores o depuradores, como Proteus o Studio 5.

Para esta práctica bastará con presionar permanentemente el botón Step Over, la razón es que en este peculiar simulador debemos presionar una tecla del teclado matricial sin que el curso del programa esté en la función Getkbd, o sea que debemos presionar una tecla cuando la flechita celeste no esté en la línea 33. Luego seguiremos presionando el botón Step Over y tendremos un resultado como se aprecia en la siguiente captura.

Habrás notado que las teclas presionadas no se corresponden con los caracteres mostrados en el terminal del USART0. Sucede que el programa utiliza un mapa de teclado diferente. Para arreglar este problema puedes cambiar la línea final del código del programa por esta otra

Data "123A456B789C*0#D"